--- /dev/null
+language: cpp
+matrix:
+ include:
+ - env: toolset=gcc
+ - os: osx
+ osx_image: xcode11.2
+ env: toolset=darwin
+
+branches:
+ only:
+ - master
+
+git:
+ submodules: false
+ depth: 1
+
+addons:
+ apt:
+ sources:
+ - ubuntu-toolchain-r-test
+ packages:
+ - libboost-tools-dev
+ - g++-9
+
+install:
+
+ - 'if [[ $TRAVIS_OS_NAME == "osx" ]]; then brew update > /dev/null && brew install boost-build; fi'
+ - 'if [[ $TRAVIS_OS_NAME != "osx" ]]; then
+ export B2=bjam;
+ else
+ export B2=b2;
+ fi'
+ - touch ~/user-config.jam
+ - 'if [[ $toolset == "gcc" ]]; then
+ g++-5 --version;
+ echo "using gcc : : g++-5 : <cxxflags>-std=c++11 ;" >> ~/user-config.jam;
+ fi'
+ - 'echo "using darwin : : clang++ : <cxxflags>-std=c++11 ;" >> ~/user-config.jam'
+
+script:
+
+ - ${B2} link=static stage_test
+ - ./test
+
--- /dev/null
+cmake_minimum_required(VERSION 2.8.12)
+project(try_signal)
+
+add_library(try_signal signal_error_code try_signal)
+target_include_directories(try_signal PUBLIC .)
+
--- /dev/null
+lib try_signal
+ : # sources
+ signal_error_code.cpp try_signal.cpp
+ : # requirements
+ : # default build
+ <link>static
+ : # usage requirements
+ <include>.
+ ;
+
+exe test : test.cpp : <library>try_signal <link>static ;
+explicit test ;
+
+exe example : example.cpp : <library>try_signal <link>static ;
+explicit example ;
+
+install stage_test : test : <location>. ;
+
--- /dev/null
+BSD 3-Clause License
+
+Copyright (c) 2016, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
--- /dev/null
+try_signal
+==========
+
+.. image:: https://travis-ci.org/arvidn/try_signal.svg?branch=master
+ :target: https://travis-ci.org/arvidn/try_signal
+
+.. image:: https://ci.appveyor.com/api/projects/status/le8jjroaai8081f1?svg=true
+ :target: https://ci.appveyor.com/project/arvidn/try-signal/branch/master
+
+The ``try_signal`` library provide a way to turn signals into C++ exceptions.
+This is especially useful when performing disk I/O via memory mapped files,
+where I/O errors are reported as ``SIGBUS`` and ``SIGSEGV`` or as structured
+exceptions on windows.
+
+The function ``try_signal`` takes a function object that will be executed once.
+If the function causes a signal (or structured exception) to be raised, it will
+throw a C++ exception. Note that RAII may not be relied upon within this function.
+It may not rely on destructors being called. Stick to simple operations like
+memcopy.
+
+Example::
+
+ #include <stdexcept>
+ #include <vector>
+ #include <numeric>
+ #include "try_signal.hpp"
+ #include <fcntl.h>
+ #include <unistd.h>
+ #include <sys/mman.h>
+
+ int main() try
+ {
+ int fd = open("test_file", O_RDWR);
+ void* map = mmap(nullptr, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+
+ std::vector<char> buf(1024);
+ std::iota(buf.begin(), buf.end(), 0);
+
+ // disk full or access after EOF are reported as exceptions
+ sig::try_signal([&]{
+ std::memcpy(map, buf.data(), buf.size());
+ });
+
+ munmap(map, 1024);
+ close(fd);
+ return 0;
+ }
+ catch (std::exception const& e)
+ {
+ fprintf(stderr, "exited with exception: %s\n", e.what());
+ return 1;
+ }
+
--- /dev/null
+version: "{build}"
+branches:
+ only:
+ - master
+os: Visual Studio 2015
+clone_depth: 1
+environment:
+ matrix:
+ - variant: debug
+ compiler: msvc-14.0
+ model: 64
+ - variant: debug
+ compiler: msvc-14.0
+ model: 32
+ - variant: release
+ compiler: msvc-14.0
+ model: 64
+ - variant: debug
+ compiler: gcc
+ model: 32
+ - variant: debug
+ compiler: gcc
+ model: 64
+ - variant: release
+ compiler: gcc
+ model: 32
+
+install:
+- set ROOT_DIRECTORY=%CD%
+- set BOOST_ROOT=c:\Libraries\boost_1_67_0
+- set BOOST_BUILD_PATH=%BOOST_ROOT%\tools\build
+- echo %BOOST_ROOT%
+- echo %BOOST_BUILD_PATH%
+- set PATH=%PATH%;%BOOST_BUILD_PATH%\src\engine\bin.ntx86
+- ps: '"using msvc : 14.0 ;`nusing gcc : : : <cxxflags>-std=c++11 ;" | Set-Content $env:HOMEDRIVE\$env:HOMEPATH\user-config.jam'
+- type %HOMEDRIVE%%HOMEPATH%\user-config.jam
+- set PATH=c:\msys64\mingw32\bin;%PATH%
+- g++ --version
+- python --version
+- echo %ROOT_DIRECTORY%
+- cd %BOOST_BUILD_PATH%\src\engine
+- build.bat >nul
+- cd %ROOT_DIRECTORY%
+
+build_script:
+# examples
+- b2.exe warnings=all warnings-as-errors=on -j2 %compiler% address-model=%model% variant=%variant% stage_test
+
+test_script:
+- test
--- /dev/null
+#include <stdexcept>
+#include <vector>
+#include <numeric>
+#include "try_signal.hpp"
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+
+int main() try
+{
+ int fd = open("test_file", O_RDWR);
+ void* map = mmap(nullptr, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+
+ std::vector<char> buf(1024);
+ std::iota(buf.begin(), buf.end(), 0);
+
+ // disk full or access after EOF are reported as exceptions
+ sig::try_signal([&]{
+ std::memcpy(map, buf.data(), buf.size());
+ });
+
+ munmap(map, 1024);
+ close(fd);
+ return 0;
+}
+catch (std::exception const& e)
+{
+ fprintf(stderr, "exited with exception: %s\n", e.what());
+ return 1;
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2016, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+ * Neither the name of the author nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include <system_error>
+#include <string>
+
+#include "signal_error_code.hpp"
+
+namespace {
+
+ struct signal_error_category : std::error_category
+ {
+ const char* name() const noexcept override
+ { return "signal"; }
+ std::string message(int ev) const noexcept override
+ {
+#define SIGNAL_CASE(x) case sig::errors::error_code_enum:: x: return #x;
+ switch (ev)
+ {
+ SIGNAL_CASE(abort)
+ SIGNAL_CASE(alarm)
+ SIGNAL_CASE(arithmetic_exception)
+ SIGNAL_CASE(hangup)
+ SIGNAL_CASE(illegal)
+ SIGNAL_CASE(interrupt)
+ SIGNAL_CASE(kill)
+ SIGNAL_CASE(pipe)
+ SIGNAL_CASE(quit)
+ case sig::errors::error_code_enum::segmentation: return "segmentation fault";
+ SIGNAL_CASE(terminate)
+ SIGNAL_CASE(user1)
+ SIGNAL_CASE(user2)
+ SIGNAL_CASE(child)
+ SIGNAL_CASE(cont)
+ SIGNAL_CASE(stop)
+ SIGNAL_CASE(terminal_stop)
+ SIGNAL_CASE(terminal_in)
+ SIGNAL_CASE(terminal_out)
+ SIGNAL_CASE(bus)
+#ifdef SIGPOLL
+ SIGNAL_CASE(poll)
+#endif
+ SIGNAL_CASE(profiler)
+ SIGNAL_CASE(system_call)
+ SIGNAL_CASE(trap)
+ SIGNAL_CASE(urgent_data)
+ SIGNAL_CASE(virtual_timer)
+ SIGNAL_CASE(cpu_limit)
+ SIGNAL_CASE(file_size_limit)
+ default: return "unknown";
+ }
+#undef SIGNAL_CASE
+ }
+ std::error_condition default_error_condition(int ev) const noexcept override
+ { return {ev, *this}; }
+ };
+} // anonymous namespace
+
+namespace sig {
+namespace errors {
+
+ std::error_code make_error_code(error_code_enum e)
+ {
+ return {e, sig_category()};
+ }
+
+ std::error_condition make_error_condition(error_code_enum e)
+ {
+ return {e, sig_category()};
+ }
+
+} // namespace errors
+
+std::error_category& sig_category()
+{
+ static signal_error_category signal_category;
+ return signal_category;
+}
+
+#ifdef _WIN32
+
+namespace {
+ sig::errors::error_code_enum map_exception_code(int const ev)
+ {
+ switch (ev)
+ {
+ case seh_errors::error_code_enum::access_violation:
+ case seh_errors::error_code_enum::array_bounds_exceeded:
+ case seh_errors::error_code_enum::guard_page:
+ case seh_errors::error_code_enum::stack_overflow:
+ case seh_errors::error_code_enum::flt_stack_check:
+ case seh_errors::error_code_enum::in_page_error:
+ return sig::errors::segmentation;
+ case seh_errors::error_code_enum::breakpoint:
+ case seh_errors::error_code_enum::single_step:
+ return sig::errors::trap;
+ case seh_errors::error_code_enum::datatype_misalignment:
+ return sig::errors::bus;
+ case seh_errors::error_code_enum::flt_denormal_operand:
+ case seh_errors::error_code_enum::flt_divide_by_zero:
+ case seh_errors::error_code_enum::flt_inexact_result:
+ case seh_errors::error_code_enum::flt_invalid_operation:
+ case seh_errors::error_code_enum::flt_overflow:
+ case seh_errors::error_code_enum::flt_underflow:
+ case seh_errors::error_code_enum::int_divide_by_zero:
+ case seh_errors::error_code_enum::int_overflow:
+ return sig::errors::arithmetic_exception;
+ case seh_errors::error_code_enum::illegal_instruction:
+ case seh_errors::error_code_enum::invalid_disposition:
+ case seh_errors::error_code_enum::priv_instruction:
+ case seh_errors::error_code_enum::noncontinuable_exception:
+ case seh_errors::error_code_enum::status_unwind_consolidate:
+ return sig::errors::illegal;
+ case seh_errors::error_code_enum::invalid_handle:
+ return sig::errors::pipe;
+ default:
+ return sig::errors::illegal;
+ }
+ }
+
+ struct seh_error_category : std::error_category
+ {
+ const char* name() const noexcept override
+ { return "SEH"; }
+ std::string message(int ev) const noexcept override
+ {
+#define SIGNAL_CASE(x) case sig::seh_errors::error_code_enum:: x: return #x;
+ switch (ev)
+ {
+ SIGNAL_CASE(access_violation)
+ SIGNAL_CASE(array_bounds_exceeded)
+ SIGNAL_CASE(guard_page)
+ SIGNAL_CASE(stack_overflow)
+ SIGNAL_CASE(flt_stack_check)
+ SIGNAL_CASE(in_page_error)
+ SIGNAL_CASE(breakpoint)
+ SIGNAL_CASE(single_step)
+ SIGNAL_CASE(datatype_misalignment)
+ SIGNAL_CASE(flt_denormal_operand)
+ SIGNAL_CASE(flt_divide_by_zero)
+ SIGNAL_CASE(flt_inexact_result)
+ SIGNAL_CASE(flt_invalid_operation)
+ SIGNAL_CASE(flt_overflow)
+ SIGNAL_CASE(flt_underflow)
+ SIGNAL_CASE(int_divide_by_zero)
+ SIGNAL_CASE(int_overflow)
+ SIGNAL_CASE(illegal_instruction)
+ SIGNAL_CASE(invalid_disposition)
+ SIGNAL_CASE(priv_instruction)
+ SIGNAL_CASE(noncontinuable_exception)
+ SIGNAL_CASE(status_unwind_consolidate)
+ SIGNAL_CASE(invalid_handle)
+ default: return "unknown";
+ }
+#undef SIGNAL_CASE
+ }
+ std::error_condition default_error_condition(int ev) const noexcept override
+ { return std::error_condition(map_exception_code(ev), sig_category()); }
+ };
+} // anonymous namespace
+
+namespace seh_errors {
+
+ std::error_code make_error_code(error_code_enum e)
+ {
+ return {static_cast<int>(e), seh_category()};
+ }
+
+} // namespace errors
+
+std::error_category& seh_category()
+{
+ static seh_error_category seh_category;
+ return seh_category;
+}
+
+#endif
+
+} // namespace sig
+
--- /dev/null
+/*
+
+Copyright (c) 2016, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+ * Neither the name of the author nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef SIGNAL_ERROR_CODE_HPP_INCLUDED
+#define SIGNAL_ERROR_CODE_HPP_INCLUDED
+
+#include <signal.h>
+#include <system_error>
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+
+#ifdef __GNUC__
+#include <excpt.h>
+#else
+#include <eh.h>
+#endif
+#endif
+
+namespace sig {
+namespace errors {
+
+#ifdef _WIN32
+#define SIG_ENUM(name, sig) name,
+#else
+#define SIG_ENUM(name, sig) name = sig,
+#endif
+
+ enum error_code_enum: int
+ {
+ SIG_ENUM(abort, SIGABRT)
+ SIG_ENUM(alarm, SIGALRM)
+ SIG_ENUM(arithmetic_exception, SIGFPE)
+ SIG_ENUM(hangup, SIGHUP)
+ SIG_ENUM(illegal, SIGILL)
+ SIG_ENUM(interrupt, SIGINT)
+ SIG_ENUM(kill, SIGKILL)
+ SIG_ENUM(pipe, SIGPIPE)
+ SIG_ENUM(quit, SIGQUIT)
+ SIG_ENUM(segmentation, SIGSEGV)
+ SIG_ENUM(terminate, SIGTERM)
+ SIG_ENUM(user1, SIGUSR1)
+ SIG_ENUM(user2, SIGUSR2)
+ SIG_ENUM(child, SIGCHLD)
+ SIG_ENUM(cont, SIGCONT)
+ SIG_ENUM(stop, SIGSTOP)
+ SIG_ENUM(terminal_stop, SIGTSTP)
+ SIG_ENUM(terminal_in, SIGTTIN)
+ SIG_ENUM(terminal_out, SIGTTOU)
+ SIG_ENUM(bus, SIGBUS)
+#ifdef SIGPOLL
+ SIG_ENUM(poll, SIGPOLL)
+#endif
+ SIG_ENUM(profiler, SIGPROF)
+ SIG_ENUM(system_call, SIGSYS)
+ SIG_ENUM(trap, SIGTRAP)
+ SIG_ENUM(urgent_data, SIGURG)
+ SIG_ENUM(virtual_timer, SIGVTALRM)
+ SIG_ENUM(cpu_limit, SIGXCPU)
+ SIG_ENUM(file_size_limit, SIGXFSZ)
+ };
+
+#undef SIG_ENUM
+
+ std::error_code make_error_code(error_code_enum e);
+ std::error_condition make_error_condition(error_code_enum e);
+
+} // namespace errors
+
+std::error_category& sig_category();
+
+#ifdef _WIN32
+namespace seh_errors {
+
+ // standard error codes are "int", the win32 exceptions are DWORD (i.e.
+ // unsigned int). We coerce them into int here for compatibility, and we're
+ // not concerned about their arithmetic
+ enum error_code_enum: int
+ {
+ access_violation = int(EXCEPTION_ACCESS_VIOLATION),
+ array_bounds_exceeded = int(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
+ guard_page = int(EXCEPTION_GUARD_PAGE),
+ stack_overflow = int(EXCEPTION_STACK_OVERFLOW),
+ flt_stack_check = int(EXCEPTION_FLT_STACK_CHECK),
+ in_page_error = int(EXCEPTION_IN_PAGE_ERROR),
+ breakpoint = int(EXCEPTION_BREAKPOINT),
+ single_step = int(EXCEPTION_SINGLE_STEP),
+ datatype_misalignment = int(EXCEPTION_DATATYPE_MISALIGNMENT),
+ flt_denormal_operand = int(EXCEPTION_FLT_DENORMAL_OPERAND),
+ flt_divide_by_zero = int(EXCEPTION_FLT_DIVIDE_BY_ZERO),
+ flt_inexact_result = int(EXCEPTION_FLT_INEXACT_RESULT),
+ flt_invalid_operation = int(EXCEPTION_FLT_INVALID_OPERATION),
+ flt_overflow = int(EXCEPTION_FLT_OVERFLOW),
+ flt_underflow = int(EXCEPTION_FLT_UNDERFLOW),
+ int_divide_by_zero = int(EXCEPTION_INT_DIVIDE_BY_ZERO),
+ int_overflow = int(EXCEPTION_INT_OVERFLOW),
+ illegal_instruction = int(EXCEPTION_ILLEGAL_INSTRUCTION),
+ invalid_disposition = int(EXCEPTION_INVALID_DISPOSITION),
+ priv_instruction = int(EXCEPTION_PRIV_INSTRUCTION),
+ noncontinuable_exception = int(EXCEPTION_NONCONTINUABLE_EXCEPTION),
+ status_unwind_consolidate = int(STATUS_UNWIND_CONSOLIDATE),
+ invalid_handle = int(EXCEPTION_INVALID_HANDLE),
+ };
+
+ std::error_code make_error_code(error_code_enum e);
+}
+
+std::error_category& seh_category();
+
+#endif // _WIN32
+
+} // namespace sig
+
+namespace std
+{
+template<>
+struct is_error_code_enum<sig::errors::error_code_enum> : std::true_type {};
+
+template<>
+struct is_error_condition_enum<sig::errors::error_code_enum> : std::true_type {};
+
+#ifdef _WIN32
+template<>
+struct is_error_code_enum<sig::seh_errors::error_code_enum> : std::true_type {};
+#endif
+
+} // namespace std
+
+#endif
+
--- /dev/null
+#include <stdexcept>
+#include <array>
+#include <cstring> // for memcpy
+
+#include "try_signal.hpp"
+
+int main()
+{
+ char const buf[] = "test...test";
+ char dest[sizeof(buf)];
+
+ {
+ sig::try_signal([&]{
+ std::memcpy(dest, buf, sizeof(buf));
+ });
+ if (!std::equal(buf, buf + sizeof(buf), dest)) {
+ fprintf(stderr, "ERROR: buffer not copied correctly\n");
+ return 1;
+ }
+ }
+
+ try {
+ void* invalid_pointer = nullptr;
+ sig::try_signal([&]{
+ std::memcpy(dest, buf, sizeof(buf));
+ std::memcpy(dest, invalid_pointer, sizeof(buf));
+ });
+ }
+ catch (std::system_error const& e)
+ {
+ if (e.code() != std::error_condition(sig::errors::segmentation)) {
+ fprintf(stderr, "ERROR: expected segmentaiton violation error\n");
+ }
+ else {
+ fprintf(stderr, "OK\n");
+ }
+ fprintf(stderr, "exited with expected system_error exception: %s\n", e.what());
+
+ // we expect this to happen, so return 0
+ return e.code() == std::error_condition(sig::errors::segmentation) ? 0 : 1;
+ }
+
+ // return non-zero here because we don't expect this
+ fprintf(stderr, "ERROR: expected exit through exception\n");
+ return 1;
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2016, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+ * Neither the name of the author nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include <cassert>
+#include <system_error>
+#include <atomic>
+#include <csetjmp>
+#include <csignal>
+
+#include "try_signal.hpp"
+
+#if !defined _WIN32
+// linux
+
+namespace sig {
+namespace detail {
+
+namespace {
+thread_local sigjmp_buf* jmpbuf = nullptr;
+}
+
+std::atomic_flag once = ATOMIC_FLAG_INIT;
+
+scoped_jmpbuf::scoped_jmpbuf(sigjmp_buf* ptr)
+{
+ _previous_ptr = jmpbuf;
+ jmpbuf = ptr;
+ std::atomic_signal_fence(std::memory_order_release);
+}
+
+scoped_jmpbuf::~scoped_jmpbuf() { jmpbuf = _previous_ptr; }
+
+void handler(int const signo, siginfo_t*, void*)
+{
+ std::atomic_signal_fence(std::memory_order_acquire);
+ if (jmpbuf)
+ siglongjmp(*jmpbuf, signo);
+
+ // this signal was not caused within the scope of a try_signal object,
+ // invoke the default handler
+ signal(signo, SIG_DFL);
+ raise(signo);
+}
+
+void setup_handler()
+{
+ struct sigaction sa;
+ sa.sa_sigaction = &sig::detail::handler;
+ sigemptyset(&sa.sa_mask);
+ sa.sa_flags = SA_SIGINFO;
+ sigaction(SIGSEGV, &sa, nullptr);
+ sigaction(SIGBUS, &sa, nullptr);
+}
+
+} // detail namespace
+} // sig namespace
+
+#elif __GNUC__
+// mingw
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+
+namespace sig {
+namespace detail {
+
+thread_local jmp_buf* jmpbuf = nullptr;
+
+long CALLBACK handler(EXCEPTION_POINTERS* pointers)
+{
+ std::atomic_signal_fence(std::memory_order_acquire);
+ if (jmpbuf)
+ longjmp(*jmpbuf, pointers->ExceptionRecord->ExceptionCode);
+ return EXCEPTION_CONTINUE_SEARCH;
+}
+
+scoped_handler::scoped_handler(jmp_buf* ptr)
+{
+ _previous_ptr = jmpbuf;
+ jmpbuf = ptr;
+ std::atomic_signal_fence(std::memory_order_release);
+ _handle = AddVectoredExceptionHandler(1, sig::detail::handler);
+}
+scoped_handler::~scoped_handler()
+{
+ RemoveVectoredExceptionHandler(_handle);
+ jmpbuf = _previous_ptr;
+}
+
+} // detail namespace
+} // sig namespace
+
+#else
+// windows
+
+#include <winnt.h> // for EXCEPTION_*
+
+namespace sig {
+namespace detail {
+
+ // these are the kinds of SEH exceptions we'll translate into C++ exceptions
+ bool catch_error(int const code)
+ {
+ return code == EXCEPTION_IN_PAGE_ERROR
+ || code == EXCEPTION_ACCESS_VIOLATION
+ || code == EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
+ }
+} // detail namespace
+} // namespace sig
+
+#endif // _WIN32
+
+
--- /dev/null
+/*
+
+Copyright (c) 2017, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+ * Neither the name of the author nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRY_SIGNAL_HPP_INCLUDED
+#define TRY_SIGNAL_HPP_INCLUDED
+
+#if !defined _WIN32
+// linux
+#include "try_signal_posix.hpp"
+#elif __GNUC__
+// mingw
+#include "try_signal_mingw.hpp"
+#else
+// windows
+#include "try_signal_msvc.hpp"
+#endif
+
+
+#endif // TRY_SIGNAL_HPP_INCLUDED
+
--- /dev/null
+/*
+
+Copyright (c) 2017, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+ * Neither the name of the author nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRY_SIGNAL_MINGW_HPP_INCLUDED
+#define TRY_SIGNAL_MINGW_HPP_INCLUDED
+
+#include "signal_error_code.hpp"
+
+#include <setjmp.h> // for jmp_buf
+
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+
+namespace sig {
+namespace detail {
+
+struct scoped_handler
+{
+ scoped_handler(jmp_buf* ptr);
+ ~scoped_handler();
+ scoped_handler(scoped_handler const&) = delete;
+ scoped_handler& operator=(scoped_handler const&) = delete;
+private:
+ void* _handle;
+ jmp_buf* _previous_ptr;
+};
+
+} // detail namespace
+
+template <typename Fun>
+void try_signal(Fun&& f)
+{
+ jmp_buf buf;
+ int const code = setjmp(buf);
+ // set the thread local jmpbuf pointer, and make sure it's cleared when we
+ // leave the scope
+ sig::detail::scoped_handler scope(&buf);
+ if (code != 0)
+ throw std::system_error(std::error_code(code, seh_category()));
+
+ f();
+}
+
+} // sig namespace
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2017, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+ * Neither the name of the author nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRY_SIGNAL_MSVC_HPP_INCLUDED
+#define TRY_SIGNAL_MSVC_HPP_INCLUDED
+
+#include "signal_error_code.hpp"
+
+namespace sig {
+namespace detail {
+
+bool catch_error(int const code);
+
+} // detail namespace
+
+template <typename Fun>
+void try_signal(Fun&& f)
+{
+ __try
+ {
+ f();
+ }
+ __except (detail::catch_error(GetExceptionCode()))
+ {
+ throw std::system_error(std::error_code(GetExceptionCode(), seh_category()));
+ }
+}
+
+} // sig namespace
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2017, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+ * Neither the name of the author nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifndef TRY_SIGNAL_POSIX_HPP_INCLUDED
+#define TRY_SIGNAL_POSIX_HPP_INCLUDED
+
+#include "signal_error_code.hpp"
+#include <setjmp.h> // for sigjmp_buf
+#include <atomic>
+
+namespace sig {
+
+namespace detail {
+
+extern std::atomic_flag once;
+
+struct scoped_jmpbuf
+{
+ explicit scoped_jmpbuf(sigjmp_buf* ptr);
+ ~scoped_jmpbuf();
+ scoped_jmpbuf(scoped_jmpbuf const&) = delete;
+ scoped_jmpbuf& operator=(scoped_jmpbuf const&) = delete;
+private:
+ sigjmp_buf* _previous_ptr;
+};
+
+void handler(int const signo, siginfo_t* si, void*);
+void setup_handler();
+
+} // detail namespace
+
+template <typename Fun>
+void try_signal(Fun&& f)
+{
+ if (sig::detail::once.test_and_set() == false) {
+ sig::detail::setup_handler();
+ }
+
+ sigjmp_buf buf;
+ int const sig = sigsetjmp(buf, 1);
+ // set the thread local jmpbuf pointer, and make sure it's cleared when we
+ // leave the scope
+ sig::detail::scoped_jmpbuf scope(&buf);
+ if (sig != 0)
+ throw std::system_error(static_cast<sig::errors::error_code_enum>(sig));
+
+ f();
+}
+
+}
+
+#endif
+
--- /dev/null
+project(libsimulator)
+cmake_minimum_required(VERSION 2.8.7)
+
+set(SRC_DIR src)
+set(TEST_SRC_DIR test)
+set(INCLUDE_DIR include)
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Boost.System is header-only (since Boost 1.69), so we only need the Boost
+# headers. Requesting the "system" component fails with recent Boost releases
+# that no longer ship a boost_system CMake config file.
+find_package(Boost REQUIRED)
+find_package(Threads REQUIRED)
+
+set(SIMULATOR_SRC_FILES
+ ${SRC_DIR}/acceptor.cpp
+ ${SRC_DIR}/high_resolution_timer.cpp
+ ${SRC_DIR}/io_service.cpp
+ ${SRC_DIR}/resolver.cpp
+ ${SRC_DIR}/sink_forwarder.cpp
+ ${SRC_DIR}/udp_socket.cpp
+ ${SRC_DIR}/default_config.cpp
+ ${SRC_DIR}/http_proxy.cpp
+ ${SRC_DIR}/pcap.cpp
+ ${SRC_DIR}/simulation.cpp
+ ${SRC_DIR}/socks_server.cpp
+ ${SRC_DIR}/high_resolution_clock.cpp
+ ${SRC_DIR}/http_server.cpp
+ ${SRC_DIR}/queue.cpp
+ ${SRC_DIR}/simulator.cpp
+ ${SRC_DIR}/tcp_socket.cpp
+ ${SRC_DIR}/nat.cpp
+)
+
+add_library(simulator ${SIMULATOR_SRC_FILES})
+target_include_directories(simulator PUBLIC ${INCLUDE_DIR})
+target_link_libraries(simulator PUBLIC Boost::boost)
+
+if(WIN32)
+ target_link_libraries(simulator PRIVATE ws2_32)
+endif()
+
+enable_testing()
+
+function(define_test)
+ set(NAME ${ARGV0})
+ add_executable(${NAME} ${TEST_SRC_DIR}/${NAME}.cpp ${TEST_SRC_DIR}/main.cpp)
+ target_link_libraries(${NAME} simulator)
+ target_link_libraries(${NAME} Threads::Threads)
+ add_test(NAME ${NAME} COMMAND ${NAME})
+endfunction()
+
+define_test(acceptor)
+define_test(multi_accept)
+define_test(multi_homed)
+define_test(null_buffers)
+define_test(parse_request)
+define_test(resolver)
+define_test(timer)
+define_test(udp_socket)
--- /dev/null
+# This Jamfile requires boost-build v2 to build.
+
+import path ;
+import modules ;
+import os ;
+import testing ;
+
+BOOST_ROOT = [ modules.peek : BOOST_ROOT ] ;
+
+ECHO "BOOST_ROOT =" $(BOOST_ROOT) ;
+ECHO "OS =" [ os.name ] ;
+
+lib wsock32 : : <name>wsock32 <link>shared ;
+lib ws2_32 : : <name>ws2_32 <link>shared ;
+
+if $(BOOST_ROOT)
+{
+ use-project /boost : $(BOOST_ROOT) ;
+ alias boost_system : /boost/system//boost_system ;
+}
+else
+{
+ local boost-lib-search-path =
+ <search>/usr/local/opt/boost/lib
+ <search>/opt/homebrew/lib
+ ;
+
+ local boost-include-path =
+ <include>/usr/local/opt/boost/include
+ <include>/opt/homebrew/include
+ ;
+
+ # boost_system is a header-only library now, but we still need to find the boost headers
+ alias boost_system : : : : $(boost-include-path) ;
+}
+
+SOURCES =
+ simulator
+ simulation
+ io_service
+ high_resolution_timer
+ high_resolution_clock
+ tcp_socket
+ udp_socket
+ queue
+ acceptor
+ default_config
+ http_server
+ socks_server
+ resolver
+ http_proxy
+ sink_forwarder
+ pcap
+ nat
+ ;
+
+lib simulator
+ : # sources
+ src/$(SOURCES).cpp
+
+ : # requirements
+ <include>include
+ <library>boost_system
+ <target-os>windows:<library>ws2_32
+ <target-os>windows:<library>wsock32
+ <threading>multi
+
+ <link>shared:<define>SIMULATOR_BUILDING_SHARED
+ <define>_CRT_SECURE_NO_WARNINGS
+
+ # https://github.com/chriskohlhoff/asio/issues/290#issuecomment-377727614
+ <define>_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING
+
+ <define>BOOST_ASIO_DISABLE_BOOST_DATE_TIME
+ <define>BOOST_ASIO_HAS_MOVE
+ <define>BOOST_ASIO_ENABLE_CANCELIO
+
+ # make sure asio uses std::chrono
+ <define>BOOST_ASIO_HAS_STD_CHRONO
+
+ # io_executor only implements the legacy (Networking TS v1) executor
+ # concept: this falls any_io_executor back to boost::asio::executor,
+ # which it can wrap, so boost::asio::ssl::stream's bookkeeping timers
+ # work for consumers that include simulator/ssl.hpp.
+ <define>BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
+
+ # disable auto-link
+ <define>BOOST_ALL_NO_LIB
+
+ : # default build
+ <warnings>all
+ <warnings-as-errors>on
+ # boost.asio has a global tss_ptr which is the head of a
+ # linked list of all invocations of run on that thread. This
+ # determines whether dispatch() will run the handler immediately
+ # not. The simulator relies on this. On windows each DLL will have
+ # its own copy of this variable, effectively causing a deadlock
+ # in the simulator. So, default to static linking
+ <link>static
+
+ : # usage requirements
+ <define>BOOST_ASIO_DISABLE_BOOST_DATE_TIME
+ <define>BOOST_ASIO_HAS_MOVE
+ <define>BOOST_ASIO_ENABLE_CANCELIO
+ <define>BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
+ <threading>multi
+ <include>include
+ <link>shared:<define>SIMULATOR_LINKING_SHARED
+
+ # https://github.com/chriskohlhoff/asio/issues/290#issuecomment-377727614
+ <define>_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING
+ ;
+
+project
+ : requirements
+ <library>simulator
+ # disable auto-link
+ <define>BOOST_ALL_NO_LIB
+ : default-build
+ <link>static
+ <threading>multi
+ <cxxstd>14
+ ;
+
+test-suite simulator-tests : [ run
+ test/main.cpp
+ test/resolver.cpp
+ test/multi_homed.cpp
+ test/timer.cpp
+ test/acceptor.cpp
+ test/multi_accept.cpp
+ test/null_buffers.cpp
+ test/udp_socket.cpp
+ test/parse_request.cpp
+ ] ;
+
--- /dev/null
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ {one line to give the program's name and a brief idea of what it does.}
+ Copyright (C) {year} {name of author}
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ {project} Copyright (C) {year} {fullname}
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+
--- /dev/null
+libsimulator
+============
+
+.. image:: https://github.com/arvidn/libsimulator/actions/workflows/ci.yml/badge.svg?branch=master
+ :target: https://github.com/arvidn/libsimulator/actions/workflows/ci.yml
+
+*This is still in initial development, some of this README represents ambitions
+rather than the current state*
+
+libsimulator is a library for running discrete event simulations, implementing
+the ``boost.asio`` API (or a somewhat faithful emulation of a subset of it,
+patches are welcome). This makes it practical to be used as a testing tool of
+real implementations of network software as well as for writing simulators that
+later turn into live production applications.
+
+The simulation has to have a single time-line to be deterministic, meaning it
+must be single threaded and use a single ``io_service`` as the message queue.
+These requirements may affect how the program to be tested is written. It may
+for instance require that an external io_service can be provided rather than one
+being wrapped in an internal thread.
+
+However, ``boost.asio`` programs may generally benefit from being transformed to
+this form, as the become *composable*, i.e. agnostic to which io_service they
+run on or how many threads are running it.
+
+features
+--------
+
+The currently (partially) supported classes are:
+
+* chrono::high_resolution_clock
+* asio::high_resolution_timer
+* asio::ip::tcp::acceptor
+* asio::ip::tcp::endpoint
+* asio::ip::address (v4 and v6 variants, these just defer to the actual
+ boost.asio types)
+* asio::ip::tcp::socket
+* asio::ip::udp::socket
+* asio::io_service
+* asio::ip::udp::resolver
+* asio::ip::tcp::resolver
+
+The ``high_resolution_clock`` in the ``chrono`` namespace implements the timer
+concept from the chrono library.
+
+usage
+-----
+
+The ``io_service`` object is significantly different from the one in boost.asio.
+This is because one simulation may only have a single message loop and a single
+ordering of events. This single message loop is provided by the ``simulation``
+class. Each simulation should have only one such object. An ``io_service``
+object represents a single node on the network. When creating an io_service, you
+have to pass in the simulation it belongs to as well as the IP address it should
+have. It is also possible to pass in multiple addresses to form a multi-homed
+node. For instance, one with both an IPv4 and IPv6 interface.
+
+When creating sockets, binding and connecting them, the io_service object
+determines what ``INADDR_ANY`` resolves to (the first IP assigned to that node).
+
+The only aspects of the io_service interface that's preserved are ``post()``,
+``dispatch()`` and constructing timers and sockets. In short, the ``run()`` and
+``poll()`` family of functions do not exist. Every io_service object is assumed
+to be run, and all of their events are handled by the simulation object.
+
+None of the synchronous APIs are supported, because that would require
+integration with OS threads and scheduler.
+
+example
+-------
+
+Here's a simple example illustrating the asio timer::
+
+ #include "simulator/simulator.hpp"
+ #include <functional>
+ #include <boost/system.hpp>
+
+ void print_time(sim::asio::high_resolution_timer& timer
+ , boost::system::error_code const& ec)
+ {
+ using namespace sim::chrono;
+ static int counter = 0;
+
+ printf("[%d] timer fired at: %d milliseconds. error: %s\n"
+ , counter
+ , int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count())
+ , ec.message().c_str());
+
+ ++counter;
+ if (counter < 5)
+ {
+ timer.expires_from_now(seconds(counter));
+ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
+ }
+ }
+
+ int main()
+ {
+ using namespace sim::chrono;
+
+ default_config cfg;
+ simulation sim(cfg);
+ io_service ios(sim, ip::address_v4::from_string("1.2.3.4"));
+ sim::asio::high_resolution_timer timer(ios);
+
+ timer.expires_from_now(seconds(1));
+ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
+
+ boost::system::error_code ec;
+ sim.run(ec);
+
+ printf("sim::run() returned: %s at: %d\n"
+ , ec.message().c_str()
+ , int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count()));
+ }
+
+The output from this program is::
+
+ [0] timer fired at: 1000 milliseconds. error: Undefined error: 0
+ [1] timer fired at: 2000 milliseconds. error: Undefined error: 0
+ [2] timer fired at: 4000 milliseconds. error: Undefined error: 0
+ [3] timer fired at: 7000 milliseconds. error: Undefined error: 0
+ [4] timer fired at: 11000 milliseconds. error: Undefined error: 0
+ io_service::run() returned: Undefined error: 0 at: 11000
+
+And obviously it doesn't take 11 wall-clock seconds to run (it returns
+instantly).
+
+configuration
+-------------
+
+The simulated network can be configured with per-node pair bandwidth, round-trip
+latency and queue sizes. This is controlled via a callback interface that
+libsimulator will ask for these properties when nodes get connected.
+
+The resolution of hostnames is also configurable by providing a callback on the
+configuration object along with the latency of individual lookups.
+
+To configure the network for the simulation, pass in a reference to an object
+implementing the ``sim::configuration`` interface::
+
+ struct configuration
+ {
+ // build the network
+ virtual void build(simulation& sim) = 0;
+
+ // return the hops on the network packets from src to dst need to traverse
+ virtual route channel_route(asio::ip::address src
+ , asio::ip::address dst) = 0;
+
+ // return the hops an incoming packet to ep need to traverse before
+ // reaching the socket (for instance a NAT)
+ virtual route incoming_route(asio::ip::address ip) = 0;
+
+ // return the hops an outgoing packet from ep need to traverse before
+ // reaching the network (for instance a DSL modem)
+ virtual route outgoing_route(asio::ip::address ip) = 0;
+
+ // return the path MTU between the two IP addresses
+ // For TCP sockets, this will be called once when the connection is
+ // established. For UDP sockets it's called for every burst of packets
+ // that are sent
+ virtual int path_mtu(asio::ip::address ip1, asio::ip::address ip2) = 0;
+
+ // called for every hostname lookup made by the client. ``reqyestor`` is
+ // the node performing the lookup, ``hostname`` is the name being looked
+ // up. Resolve the name into addresses and fill in ``result`` or set
+ // ``ec`` if the hostname is not found or some other error occurs. The
+ // return value is the latency of the lookup. The client's callback won't
+ // be called until after waiting this long.
+ virtual chrono::high_resolution_clock::duration hostname_lookup(
+ asio::ip::address const& requestor
+ , std::string hostname
+ , std::vector<asio::ip::address>& result
+ , boost::system::error_code& ec) = 0;
+ };
+
+``build()`` is called right after the simulation is constructed. It gives the
+configuration object an opportunity to construct the core queues, since they
+need access to the simulator.
+
+``channel_route()`` is expected to return a *route* of network hops from the
+source IP to the destination IP. A route is a series of ``sink`` objects. The
+typical sink is a ``sim::queue``, which is a network node with a specific rate
+limit, propagation delay and queue size.
+
+*TODO: finish document configuration interface*
+
+history
+-------
+
+libsimulator grew out of libtorrent's unit tests, as a tool to make them reliable
+and deterministic (i.e. not depend on external systems like sockets and timers)
+and also easier to debug. The subset of the asio API initially supported by this
+library is the subset used by libtorrent. Patches are welcome to improve
+fidelity and support.
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef CHRONO_HPP_INCLUDED
+#define CHRONO_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include "simulator/config.hpp"
+
+#if defined BOOST_ASIO_HAS_STD_CHRONO
+#include <chrono>
+#else
+#include "simulator/push_warnings.hpp"
+
+#include <boost/chrono/duration.hpp>
+#include <boost/chrono/time_point.hpp>
+#include <boost/ratio.hpp>
+
+#include "simulator/pop_warnings.hpp"
+#endif
+
+namespace sim { namespace chrono
+{
+#if defined BOOST_ASIO_HAS_STD_CHRONO
+ using std::chrono::seconds;
+ using std::chrono::milliseconds;
+ using std::chrono::microseconds;
+ using std::chrono::nanoseconds;
+ using std::chrono::minutes;
+ using std::chrono::hours;
+ using std::chrono::duration_cast;
+ using std::chrono::time_point;
+ using std::chrono::duration;
+#else
+ using boost::chrono::seconds;
+ using boost::chrono::milliseconds;
+ using boost::chrono::microseconds;
+ using boost::chrono::nanoseconds;
+ using boost::chrono::minutes;
+ using boost::chrono::hours;
+ using boost::chrono::duration_cast;
+ using boost::chrono::time_point;
+ using boost::chrono::duration;
+#endif
+
+ // std.chrono / boost.chrono compatible high_resolution_clock using a simulated time
+ struct SIMULATOR_DECL high_resolution_clock
+ {
+ using rep = std::int64_t;
+#if defined BOOST_ASIO_HAS_STD_CHRONO
+ using period = std::nano;
+ using time_point = std::chrono::time_point<high_resolution_clock, nanoseconds>;
+ using duration = std::chrono::duration<boost::int64_t, std::nano>;
+#else
+ using period = boost::nano;
+ using time_point = time_point<high_resolution_clock, nanoseconds>;
+ using duration = duration<boost::int64_t, boost::nano>;
+#endif
+ static const bool is_steady = true;
+ static time_point now();
+
+ // private interface
+ static void fast_forward(high_resolution_clock::duration d);
+ };
+
+ SIMULATOR_DECL void reset_clock();
+
+} // chrono
+} // sim
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef CONFIG_HPP_INCLUDED
+#define CONFIG_HPP_INCLUDED
+
+#include "simulator/push_warnings.hpp"
+#include <boost/config.hpp>
+#include "simulator/pop_warnings.hpp"
+
+#ifdef SIMULATOR_BUILDING_SHARED
+#define SIMULATOR_DECL BOOST_SYMBOL_EXPORT
+#elif defined SIMULATOR_LINKING_SHARED
+#define SIMULATOR_DECL BOOST_SYMBOL_IMPORT
+#else
+#define SIMULATOR_DECL
+#endif
+
+#if defined __clang__ || defined __GNUC__
+#define LIBSIMULATOR_NO_RETURN __attribute((noreturn))
+#elif _MSC_VER
+#define LIBSIMULATOR_NO_RETURN __declspec(noreturn)
+#else
+#define LIBSIMULATOR_NO_RETURN
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push)
+// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
+#pragma warning( disable : 4251)
+// warning C4661: X: no suitable definition provided for explicit template instantiation request
+#pragma warning( disable : 4661)
+#endif
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2017, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef SIMULATOR_FUNCTION_HPP_INCLUDED
+#define SIMULATOR_FUNCTION_HPP_INCLUDED
+
+#include <utility>
+#include <memory> // for allocator_traits
+
+#include "simulator/mallocator.hpp"
+
+namespace sim {
+namespace aux {
+
+ template <typename T, typename U>
+ T exchange_(T& var, U&& new_val)
+ {
+ T temp = std::move(var);
+ var = std::forward<U>(new_val);
+ return temp;
+ }
+
+ template <typename T, typename Fun>
+ T* allocate_handler(Fun h)
+ {
+ using alloc = typename boost::asio::associated_allocator<typename std::remove_reference<Fun>::type>::type;
+ using our_alloc = typename std::allocator_traits<alloc>::template rebind_alloc<T>;
+ our_alloc al(boost::asio::get_associated_allocator(h));
+ void* ptr = al.allocate(1);
+ if (ptr == nullptr) throw std::bad_alloc();
+ try {
+ return new (ptr) T(std::move(h));
+ }
+ catch (...) {
+ al.deallocate(reinterpret_cast<T*>(ptr), 1);
+ throw;
+ }
+ }
+
+ // this is a std::function-like class that supports move-only function
+ // objects
+ template <typename R, typename... A>
+ struct callable
+ {
+ using call_fun_t = R (*)(void*, A&&...);
+ using deallocate_fun_t = void (*)(void*);
+ call_fun_t call_fun;
+ deallocate_fun_t deallocate_fun;
+ };
+
+ template <typename Handler, typename R, typename... A>
+ R call_impl(void* mem, A&&... a);
+
+ template <typename Handler, typename R, typename... A>
+ void dealloc_impl(void* mem);
+
+ template <typename Handler, typename R, typename... A>
+ struct function_impl : callable<R, A...>
+ {
+ function_impl(Handler h)
+ : handler(std::move(h))
+ {
+ this->call_fun = call_impl<Handler, R, A&&...>;
+ this->deallocate_fun = dealloc_impl<Handler, R, A&&...>;
+ }
+ Handler handler;
+ };
+
+ template <typename Handler, typename R, typename... A>
+ R call_impl(void* mem, A&&... a)
+ {
+ auto* obj = static_cast<function_impl<Handler, R, A...>*>(mem);
+ Handler handler = std::move(obj->handler);
+
+ obj->~function_impl();
+ using alloc = typename boost::asio::associated_allocator<Handler>::type;
+ using our_alloc = typename std::allocator_traits<alloc>::
+ template rebind_alloc<typename std::remove_reference<decltype(*obj)>::type>;
+ our_alloc al(boost::asio::get_associated_allocator(handler));
+ al.deallocate(obj, 1);
+
+ return handler(std::forward<A>(a)...);
+ }
+
+ template <typename Handler, typename R, typename... A>
+ void dealloc_impl(void* mem)
+ {
+ auto* obj = static_cast<function_impl<Handler, R, A...>*>(mem);
+ Handler h = std::move(obj->handler);
+
+ obj->~function_impl();
+ using alloc = typename boost::asio::associated_allocator<Handler>::type;
+ using our_alloc = typename std::allocator_traits<alloc>::
+ template rebind_alloc<typename std::remove_reference<decltype(*obj)>::type>;
+ our_alloc al(boost::asio::get_associated_allocator(h));
+ al.deallocate(obj, 1);
+ }
+
+ template <typename Fun>
+ struct function;
+
+ template <typename R, typename... A>
+ struct function<R(A...)>
+ {
+ using result_type = R;
+
+ using allocator_type = aux::mallocator<R(A...)>;
+ allocator_type get_allocator() const { return allocator_type{}; }
+
+ template <typename C>
+ function(C c)
+ : m_callable(allocate_handler<function_impl<C, R, A...>>(std::move(c)))
+ {}
+ function(function&& other) noexcept
+ : m_callable(exchange_(other.m_callable, nullptr))
+ {}
+ function& operator=(function&& other) noexcept
+ {
+ if (&other == this) return *this;
+ clear();
+ m_callable = exchange_(other.m_callable, nullptr);
+ return *this;
+ }
+
+ ~function() { clear(); }
+
+ // boost.asio requires handlers to be copy-constructible, but it will move
+ // them, if they're movable. So we trick asio into accepting this handler.
+ // If it attempts to copy, it will cause a link error
+ function(function const&) { assert(false && "functions should not be copied"); }
+ function& operator=(function const&) = delete;
+
+ function() = default;
+ explicit operator bool() const { return m_callable != nullptr; }
+ function& operator=(std::nullptr_t) { clear(); return *this; }
+ void clear()
+ {
+ if (m_callable == nullptr) return;
+ auto fun = m_callable->deallocate_fun;
+ fun(m_callable);
+ m_callable = nullptr;
+ }
+ template <typename... Args>
+ R operator()(Args&&... a)
+ {
+ assert(m_callable);
+ auto fun = m_callable->call_fun;
+ return fun(exchange_(m_callable, nullptr), std::forward<A>(a)...);
+ }
+ private:
+ callable<R, A...>* m_callable = nullptr;
+ };
+
+ // index sequence, to unpack tuple
+ template<std::size_t...> struct seq {};
+ template<std::size_t N, std::size_t... S> struct gens : gens<N-1, N-1, S...> {};
+ template<std::size_t... S> struct gens<0, S...> { using type = seq<S...>; };
+
+ // a binder for move-only types, and movable arguments. It's not a general
+ // binder as it doesn't support partial application, it just binds all
+ // arguments and ignores any arguments passed to the call
+ template <typename Callable, typename R, typename... A>
+ struct move_binder
+ {
+ move_binder(Callable c, A&&... a)
+ : m_args(std::move(a)...)
+ , m_callable(std::move(c))
+ {}
+
+ move_binder(move_binder const&) = delete;
+ move_binder& operator=(move_binder const&) = delete;
+
+ move_binder(move_binder&&) = default;
+ move_binder& operator=(move_binder&&) = default;
+
+ // ignore any arguments passed in. This is used to ignore an error_code
+ // argument for instance
+ template <typename... Args>
+ R operator()(Args...)
+ {
+ return call(typename gens<sizeof...(A)>::type());
+ }
+
+ private:
+
+ template<std::size_t... I>
+ R call(seq<I...>)
+ {
+ return m_callable(std::move(std::get<I>(m_args))...);
+ }
+ std::tuple<A...> m_args;
+ Callable m_callable;
+ };
+
+ template <typename R, typename C, typename... A>
+ move_binder<C, R, A...> move_bind(C c, A&&... a)
+ {
+ return move_binder<C, R, A...>(std::move(c), std::forward<A>(a)...);
+ }
+
+}
+}
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef HANDLER_ALLOCATOR_HPP_INCLUDED
+#define HANDLER_ALLOCATOR_HPP_INCLUDED
+
+namespace sim
+{
+namespace aux
+{
+
+template <typename T>
+struct malloc_allocator
+{
+ using value_type = T;
+ using size_type = std::size_t;
+
+ friend bool operator==(malloc_allocator, malloc_allocator) { return true; }
+ friend bool operator!=(malloc_allocator, malloc_allocator) { return false; }
+
+ template <class U>
+ struct rebind { using other = malloc_allocator<U>; };
+
+ malloc_allocator() = default;
+ template <typename U>
+ malloc_allocator(malloc_allocator<U> const&) {}
+
+ T* allocate(std::size_t size) { return static_cast<T*>(std::malloc(size * sizeof(T))); }
+ void deallocate(T* pointer, std::size_t) { std::free(pointer); }
+ using is_always_equal = std::true_type;
+};
+
+// this is a handler wrapper that customizes the asio handler allocator to use
+// malloc instead of new. The purpose is to distinguish allocations that are
+// internal to the simulator and allocations part of the program under test.
+template <typename Handler>
+struct malloc_wrapper
+{
+ malloc_wrapper(Handler h) : m_handler(std::move(h)) {}
+
+ template <typename... Args>
+ void operator()(Args&&... a)
+ {
+ m_handler(std::forward<Args>(a)...);
+ }
+
+ using allocator_type = malloc_allocator<malloc_wrapper<Handler>>;
+
+ allocator_type get_allocator() const noexcept
+ { return allocator_type{}; }
+
+private:
+ Handler m_handler;
+};
+
+template <typename T>
+malloc_wrapper<T> make_malloc(T h)
+{
+ return malloc_wrapper<T>(std::move(h));
+}
+
+}
+}
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef HTTP_PROXY_HPP_INCLUDED
+#define HTTP_PROXY_HPP_INCLUDED
+
+#include "simulator/simulator.hpp"
+
+#ifdef _MSC_VER
+#pragma warning(push)
+// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
+#pragma warning( disable : 4251)
+#endif
+
+namespace sim
+{
+ struct http_request;
+
+// This is a very simple http proxy that only supports a single
+// concurrent connection
+struct SIMULATOR_DECL http_proxy
+{
+ http_proxy(asio::io_context& ios, unsigned short listen_port);
+
+ void stop();
+
+private:
+
+ void on_accept(boost::system::error_code const& ec);
+ void on_read_request(boost::system::error_code const& ec, size_t bytes_transferred);
+
+ void forward_request(http_request const& req);
+ void open_forward_connection(const asio::ip::tcp::endpoint& target);
+ void on_connected(boost::system::error_code const& ec);
+
+ void on_domain_lookup(boost::system::error_code const& ec
+ , const asio::ip::tcp::resolver::results_type ips);
+
+ void write_server_send_buffer();
+ void on_server_write(boost::system::error_code const& ec, size_t bytes_transferred);
+
+ void on_server_receive(boost::system::error_code const& ec
+ , std::size_t bytes_transferred);
+ void on_server_forward(boost::system::error_code const& ec, size_t bytes_transferred);
+
+ void error(int code, char const* message);
+ void close_connection();
+
+ asio::ip::tcp::resolver m_resolver;
+ asio::ip::tcp::acceptor m_listen_socket;
+
+ // this is the client connection, i.e. the client connecting to us, sending
+ // HTTP requests that we forward
+ asio::ip::tcp::socket m_client_connection;
+ // client endpoint
+ asio::ip::tcp::endpoint m_ep;
+
+ // this is the connection to the server the client's requests are forwarded
+ // to
+ asio::ip::tcp::socket m_server_connection;
+ // true while there is an outstanding write operation to the server
+ bool m_writing_to_server;
+
+ // receive buffer for requests from the client. i.e. client -> proxy (us) -> server
+ char m_client_in_buffer[65536];
+ // buffer size
+ int m_num_client_in_bytes;
+
+ char m_server_out_buffer[65536];
+ int m_num_server_out_bytes;
+
+ // receive buffer for incoming responses, i.e. server -> proxy (us) -> client
+ char m_in_buffer[65536];
+ // buffer size
+ int m_num_in_bytes;
+
+ // set to true when shutting down
+ bool m_close;
+};
+
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef HTTP_SERVER_HPP_INCLUDED
+#define HTTP_SERVER_HPP_INCLUDED
+
+#include "simulator/simulator.hpp"
+#include <string>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
+#pragma warning( disable : 4251)
+#endif
+
+namespace sim
+{
+ std::string SIMULATOR_DECL trim(std::string s);
+
+ std::string SIMULATOR_DECL lower_case(std::string s);
+
+ std::string SIMULATOR_DECL normalize(const std::string& s);
+
+ // returns the index to the last byte of the request, or -1 if the buffer
+ // does not contain a full http request
+ int SIMULATOR_DECL find_request_len(char const* buf, int len);
+
+ struct http_request
+ {
+ std::string method;
+ std::string req;
+ std::string path;
+ std::map<std::string, std::string> headers;
+ };
+
+ http_request parse_request(char const* start, int len);
+
+ // builds an HTTP response buffer
+ std::string SIMULATOR_DECL send_response(int code, char const* status_message
+ , int len = 0, char const** extra_header = NULL);
+
+// This is a very simple http server that only supports a single concurrent
+// connection
+struct SIMULATOR_DECL http_server
+{
+ enum flags_t
+ {
+ keep_alive = 1,
+ // behave like an HTTP/1.0 server: respond with an HTTP/1.0 status line
+ // and close the connection after each response. HTTP/1.0 has no
+ // persistent connections, and the Connection header is an HTTP/1.1
+ // mechanism, so no "Connection: close" is sent -- the client must detect
+ // the close from the protocol version (and the socket closing).
+ http_1_0 = 2
+ };
+
+ http_server(asio::io_context& ios, unsigned short listen_port
+ , int flags = http_server::keep_alive);
+
+ void stop();
+
+ using handler_t = std::function<std::string (std::string, std::string
+ , std::map<std::string, std::string>&)>;
+ using generator_t = std::function<std::string (std::int64_t, std::int64_t)>;
+
+ void register_handler(std::string const& path, handler_t h);
+ void register_content(std::string const& path
+ , std::int64_t const size, generator_t gen);
+ void register_redirect(std::string const& path, std::string const& target);
+ void register_stall_handler(std::string const& path);
+
+ // the number of TCP connections that have been accepted so far
+ int accepted_connections() const { return m_accepted_connections; }
+
+private:
+
+ void on_accept(boost::system::error_code const& ec);
+ void read();
+ void on_read(boost::system::error_code const& ec, size_t bytes_transferred);
+ void on_write(boost::system::error_code const& ec, size_t bytes_transferred
+ , bool close);
+ void close_connection();
+
+ asio::io_context& m_ios;
+
+ asio::ip::tcp::acceptor m_listen_socket;
+
+ asio::ip::tcp::socket m_connection;
+ asio::ip::tcp::endpoint m_ep;
+
+ std::unordered_map<std::string, handler_t> m_handlers;
+ std::set<std::string> m_stall_handlers;
+
+ // read buffer, we receive bytes into this buffer for the connection
+ std::string m_recv_buffer;
+
+ // the number of bytes of m_recv_buffer that we've actually read data into.
+ // The remaining is uninitialized, possibly being read into in an async call
+ int m_bytes_used;
+
+ std::string m_send_buffer;
+
+ // set to true when shutting down
+ bool m_close;
+
+ int m_flags;
+
+ // counts the number of accepted TCP connections
+ int m_accepted_connections = 0;
+};
+
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2017, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef SIMULATOR_MALLOCATOR_HPP_INCLUDED
+#define SIMULATOR_MALLOCATOR_HPP_INCLUDED
+
+namespace sim
+{
+namespace aux
+{
+ struct channel;
+ struct packet;
+ struct pcap;
+
+ template <typename T>
+ struct mallocator
+ {
+ template <typename U>
+ friend struct mallocator;
+
+ using value_type = T;
+ using pointer = T*;
+ using const_pointer = T const*;
+ using reference = T&;
+ using const_reference = T const&;
+ using size_type = std::size_t;
+ using difference_type = std::ptrdiff_t;
+
+ template <class U>
+ struct rebind {
+ using other = mallocator<U>;
+ };
+
+ mallocator() = default;
+ template <typename U>
+ mallocator(mallocator<U> const&) {}
+
+ T* allocate(std::size_t size)
+ { return reinterpret_cast<T*>(std::malloc(size * sizeof(T))); }
+
+ void deallocate(T* ptr) { std::free(ptr); }
+ void deallocate(T* ptr, std::size_t) { std::free(ptr); }
+
+ void destroy(pointer p) { p->~T(); }
+ void construct(pointer p, T&& value) { new (p) T(std::move(value)); }
+
+ bool operator==(mallocator const&) const { return true; }
+ bool operator!=(mallocator const&) const { return false; }
+ };
+} // aux
+} // sim
+
+#endif // SIMULATOR_MALLOCATOR_HPP_INCLUDED
+
--- /dev/null
+/*
+
+Copyright (c) 2018, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef NAT_HPP_INCLUDED
+#define NAT_HPP_INCLUDED
+
+#include "simulator/sink.hpp"
+#include "simulator/simulator.hpp"
+#include <string>
+
+namespace sim {
+
+namespace aux {
+ struct packet;
+}
+
+ struct SIMULATOR_DECL nat : sink
+ {
+ nat(asio::ip::address external_addr);
+ ~nat() = default;
+
+ void incoming_packet(aux::packet p) override;
+
+ // used for visualization
+ std::string label() const override;
+
+ private:
+
+ asio::ip::address m_external_addr;
+ };
+
+} // sim
+
+#endif
+
+
--- /dev/null
+/*
+
+Copyright (c) 2017, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef NOEXCEPT_MOVABLE_HPP_INCLUDED
+#define NOEXCEPT_MOVABLE_HPP_INCLUDED
+
+namespace sim {
+namespace aux {
+
+ template <typename T>
+ struct noexcept_movable : T
+ {
+ noexcept_movable() noexcept {}
+ noexcept_movable(noexcept_movable<T>&& rhs) noexcept
+ : T(std::forward<T>(rhs))
+ {}
+ noexcept_movable(noexcept_movable<T> const& rhs)
+ : T(static_cast<T const&>(rhs))
+ {}
+ noexcept_movable(T&& rhs) noexcept : T(std::forward<T>(rhs)) {} // NOLINT
+ noexcept_movable(T const& rhs) : T(rhs) {} // NOLINT
+ noexcept_movable& operator=(noexcept_movable&& rhs) noexcept
+ {
+ this->T::operator=(std::forward<T>(rhs));
+ return *this;
+ }
+ noexcept_movable& operator=(noexcept_movable const& rhs)
+ {
+ this->T::operator=(rhs);
+ return *this;
+ }
+
+ using T::T;
+ using T::operator=;
+ };
+
+}
+}
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef PACKET_HPP_INCLUDED
+#define PACKET_HPP_INCLUDED
+
+#include "simulator/config.hpp"
+#include "simulator/simulator.hpp" // for route, endpoint
+
+namespace sim { namespace aux {
+
+ struct channel;
+
+ struct packet
+ {
+ packet() = default;
+
+ // this is move-only
+ packet(packet const&) = delete;
+ packet& operator=(packet const&) = delete;
+ packet(packet&&) = default;
+ packet& operator=(packet&&) = default;
+
+ // to keep things simple, don't drop ACKs or errors
+ bool ok_to_drop() const
+ {
+ return type != type_t::syn_ack
+ && type != type_t::ack
+ && type != type_t::error;
+ }
+
+ enum class type_t
+ {
+ uninitialized, // invalid type (used for debugging)
+ syn, // TCP connect
+ syn_ack, // TCP connection accepted
+ ack, // the seq_nr is interpreted as "we received this"
+ error, // the error_code (ec) is set
+ payload // the buffer is filled
+ };
+
+ type_t type = type_t::uninitialized;
+
+ boost::system::error_code ec;
+
+ // actual payload
+ std::vector<boost::uint8_t> buffer;
+
+ // used for UDP packets
+ asio::ip::udp::endpoint from;
+
+ // the number of bytes of overhead for this packet. The total packet
+ // size is the number of bytes in the buffer + this number
+ int overhead = 20;
+
+ // each hop in the route will pop itself off and forward the packet to
+ // the next hop
+ route hops;
+
+ // for SYN packets, this is set to the channel we're trying to
+ // establish
+ std::shared_ptr<aux::channel> channel;
+
+ // sequence number of this packet (used for debugging)
+ std::uint64_t seq_nr = 0;
+
+ // the number of (payload) bytes sent over this channel so far. This is
+ // meant to map to the TCP sequence number
+ std::uint32_t byte_counter = 0;
+
+ // this function must be called with this packet in case the packet is
+ // dropped.
+ aux::function<void(aux::packet)> drop_fun;
+ };
+
+}} // sim
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2017, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef PCAP_HPP_INCLUDED
+#define PCAP_HPP_INCLUDED
+
+#include <fstream>
+#include "simulator/simulator.hpp" // for endpoint
+
+namespace sim { namespace aux
+{
+ struct packet;
+
+ struct pcap
+ {
+ pcap(char const* filename);
+ void log_tcp(packet const& p, asio::ip::tcp::endpoint src
+ , asio::ip::tcp::endpoint dst);
+ void log_udp(packet const& p, asio::ip::udp::endpoint src
+ , asio::ip::udp::endpoint dst);
+ private:
+ std::fstream m_file;
+ };
+}}
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+ * Neither the name of the author nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the distribution.
+ * Neither the name of the author nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wall"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#pragma GCC diagnostic ignored "-Wconversion"
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#pragma GCC diagnostic ignored "-Wundef"
+#pragma GCC diagnostic ignored "-Wmissing-noreturn"
+#pragma GCC diagnostic ignored "-Wdeprecated"
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#pragma GCC diagnostic ignored "-Wshadow"
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#pragma GCC diagnostic ignored "-Wpedantic"
+#if __GNUC__ >= 6
+#pragma GCC diagnostic ignored "-Wshift-overflow"
+#pragma GCC diagnostic ignored "-Wshift-count-overflow"
+#pragma GCC diagnostic ignored "-Wshift-count-negative"
+#endif
+#endif
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wall"
+#pragma clang diagnostic ignored "-Weverything"
+#pragma clang diagnostic ignored "-Wsign-conversion"
+#pragma clang diagnostic ignored "-Wconversion"
+#pragma clang diagnostic ignored "-Wswitch-enum"
+#pragma clang diagnostic ignored "-Wcovered-switch-default"
+#pragma clang diagnostic ignored "-Wold-style-cast"
+#pragma clang diagnostic ignored "-Wundef"
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#pragma clang diagnostic ignored "-Wmissing-noreturn"
+#pragma clang diagnostic ignored "-Wdeprecated"
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#pragma clang diagnostic ignored "-Wcast-align"
+#pragma clang diagnostic ignored "-Wweak-vtable"
+#pragma clang diagnostic ignored "-Wundef"
+#pragma clang diagnostic ignored "-Wshadow"
+#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
+#pragma clang diagnostic ignored "-Wc++11-long-long"
+#pragma clang diagnostic ignored "-Wc++11-extensions"
+#pragma clang diagnostic ignored "-Wextra-semi"
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wreserved-id-macro"
+#pragma clang diagnostic ignored "-Wunused-local-typedef"
+#pragma clang diagnostic ignored "-Wgnu-folding-constant"
+#pragma clang diagnostic ignored "-Wdouble-promotion"
+#pragma clang diagnostic ignored "-Wfloat-equal"
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push, 1)
+// warning C4005: macro redefinition
+#pragma warning( disable : 4005 )
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef QUEUE_HPP_INCLUDED
+#define QUEUE_HPP_INCLUDED
+
+#include "simulator/simulator.hpp"
+#include "simulator/packet.hpp"
+#include "simulator/mallocator.hpp"
+
+#ifdef _MSC_VER
+#pragma warning(push)
+// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
+#pragma warning( disable : 4251)
+#endif
+
+namespace sim {
+
+ struct timed_packet
+ {
+ timed_packet(chrono::high_resolution_clock::time_point t, aux::packet p)
+ : ts(t), pkt(std::move(p))
+ {}
+ timed_packet(timed_packet&&) = default;
+ timed_packet& operator=(timed_packet&&) = default;
+ timed_packet(timed_packet const&) = delete;
+ timed_packet& operator=(timed_packet const&) = delete;
+ chrono::high_resolution_clock::time_point ts;
+ aux::packet pkt;
+ };
+
+ // this is a queue. It can be configured to contrain
+ struct SIMULATOR_DECL queue : sink
+ {
+ queue(asio::io_context& ios, int bandwidth
+ , chrono::high_resolution_clock::duration propagation_delay
+ , int max_queue_size, std::string name = "queue");
+
+ virtual void incoming_packet(aux::packet p) override final;
+
+ virtual std::string label() const override final;
+
+ queue(queue const&) = delete;
+ queue& operator=(queue const&) = delete;
+
+ queue(queue&&) = default;
+ queue& operator=(queue&&) = delete;
+
+ private:
+
+ void begin_send_next_packet();
+ void next_packet_sent();
+
+ // the queue can't hold more than this number of bytes. Once it's full,
+ // any new packets arriving will be dropped (tail drop)
+ int m_max_queue_size;
+
+ // the amount of time it takes to forward a packet. Every packet is
+ // delayed by at least this much before being forwarded
+ chrono::high_resolution_clock::duration m_forwarding_latency;
+
+ // the number of bytes per second that can be sent. This includes the
+ // packet overhead
+ int m_bandwidth;
+
+ // the number of bytes currently in the packet queue
+ int m_queue_size;
+
+ std::string m_node_name;
+
+ // this is the queue of packets and the time each packet was enqueued
+ std::deque<timed_packet, aux::mallocator<timed_packet>> m_queue;
+ asio::high_resolution_timer m_forward_timer;
+
+ chrono::high_resolution_clock::time_point m_last_forward;
+ };
+
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef SIMULATOR_HPP_INCLUDED
+#define SIMULATOR_HPP_INCLUDED
+
+#include "simulator/push_warnings.hpp"
+
+#include <boost/config.hpp>
+#include <boost/asio/detail/config.hpp>
+#include <boost/asio/basic_deadline_timer.hpp>
+#include <boost/asio/ip/udp.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/write.hpp>
+#include <boost/asio/read.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/system/error_code.hpp>
+#include <boost/asio/ip/network_v4.hpp>
+#include <boost/asio/buffers_iterator.hpp>
+
+#include <boost/asio/post.hpp>
+#include <boost/asio/defer.hpp>
+#include <boost/asio/dispatch.hpp>
+#include <boost/asio/error.hpp>
+
+// only for boost::beast::role_type, used by the teardown()/async_teardown()
+// overloads below (customization points boost::beast::websocket::stream
+// needs for any non-boost::asio socket type it's instantiated over); this
+// is the single lightweight header that defines it, not a dependency on
+// beast's websocket/http machinery.
+#include <boost/beast/core/role.hpp>
+
+#include <boost/optional.hpp>
+
+#include "simulator/pop_warnings.hpp"
+
+#include "simulator/chrono.hpp"
+#include "simulator/sink_forwarder.hpp"
+#include "simulator/function.hpp"
+#include "simulator/noexcept_movable.hpp"
+#include "simulator/mallocator.hpp"
+
+#include <deque>
+#include <memory>
+#include <mutex>
+#include <map>
+#include <unordered_map>
+#include <unordered_set>
+#include <set>
+#include <vector>
+#include <list>
+#include <functional>
+#include <utility>
+
+#ifndef IP_DONTFRAGMENT
+#define IP_DONTFRAGMENT 1
+#endif
+
+namespace sim
+{
+ namespace aux
+ {
+ struct channel;
+ struct packet;
+ struct pcap;
+
+ // this is outgoing NIC bandwidth
+ constexpr int nic_bandwidth = 100000000; // 100 MB/s
+ }
+
+ // this represents a network route (a series of sinks to pass a packet
+ // through)
+ struct SIMULATOR_DECL route
+ {
+ friend route operator+(route lhs, route rhs)
+ { return std::move(lhs.append(std::move(rhs))); }
+
+ std::shared_ptr<sink> next_hop() const { return hops.front(); }
+ std::shared_ptr<sink> pop_front()
+ {
+ if (hops.empty()) return std::shared_ptr<sink>();
+ std::shared_ptr<sink> ret(std::move(hops.front()));
+ hops.erase(hops.begin());
+ return ret;
+ }
+ void replace_last(std::shared_ptr<sink> s) { hops.back() = std::move(s); }
+ void prepend(route const& r)
+ { hops.insert(hops.begin(), r.hops.begin(), r.hops.end()); }
+ void prepend(std::shared_ptr<sink> s) { hops.insert(hops.begin(), std::move(s)); }
+ route& append(route const& r)
+ { hops.insert(hops.end(), r.hops.begin(), r.hops.end()); return *this; }
+ route& append(std::shared_ptr<sink> s) { hops.push_back(std::move(s)); return *this; }
+ bool empty() const { return hops.empty(); }
+ std::shared_ptr<sink> last() const
+ { return hops.back(); }
+
+ private:
+ std::deque<std::shared_ptr<sink>, aux::mallocator<std::shared_ptr<sink>>> hops;
+ };
+
+ void forward_packet(aux::packet p);
+
+ struct simulation;
+ struct configuration;
+ struct queue;
+
+ namespace asio
+ {
+
+ using boost::asio::buffer_size;
+ using boost::asio::const_buffer;
+ using boost::asio::mutable_buffer;
+ using boost::asio::buffer;
+
+ // brought in here (rather than relying on ADL at each call site below)
+ // so buffer sequence types whose associated namespaces don't include
+ // boost::asio (e.g. boost::beast's internal buffer sequence types) are
+ // still found; the "using" also participates in ADL's overload set at
+ // the point of an unqualified call, so this doesn't shadow lookups for
+ // types that do live in boost::asio.
+ using boost::asio::buffer_sequence_begin;
+ using boost::asio::buffer_sequence_end;
+
+ using boost::asio::post;
+ using boost::asio::dispatch;
+ using boost::asio::defer;
+
+ struct io_context;
+
+ struct io_executor
+ {
+ io_executor(io_context& ctx) : m_ctx(&ctx) {}
+ io_context& context() const { return *m_ctx; }
+
+ template <typename Handler, typename Allocator>
+ void dispatch(Handler handler, Allocator const& a) const;
+
+ template <typename Handler, typename Allocator>
+ void post(Handler handler, Allocator const& a) const;
+
+ template <typename Handler, typename Allocator>
+ void defer(Handler handler, Allocator const& a) const;
+
+ void on_work_finished() const {}
+ void on_work_started() const {}
+
+ bool running_in_this_thread() const { return true; }
+
+ friend bool operator==(io_executor const& lhs, io_executor const& rhs)
+ { return lhs.m_ctx == rhs.m_ctx; }
+
+ friend bool operator!=(io_executor const& lhs, io_executor const& rhs)
+ { return lhs.m_ctx != rhs.m_ctx; }
+
+ private:
+ io_context* m_ctx;
+ };
+
+ struct SIMULATOR_DECL high_resolution_timer
+ {
+ friend struct sim::simulation;
+
+ using time_type = chrono::high_resolution_clock::time_point;
+ using duration_type = chrono::high_resolution_clock::duration;
+
+ using executor_type = io_executor;
+ executor_type get_executor();
+
+ explicit high_resolution_timer(io_context& io_context);
+ high_resolution_timer(io_context& io_context,
+ const time_type& expiry_time);
+ high_resolution_timer(io_context& io_context,
+ const duration_type& expiry_time);
+ high_resolution_timer(high_resolution_timer&&) noexcept = default;
+ high_resolution_timer& operator=(high_resolution_timer&&) noexcept = default;
+ ~high_resolution_timer();
+
+ std::size_t cancel();
+ std::size_t cancel_one();
+
+ time_type expiry() const;
+ std::size_t expires_at(const time_type& expiry_time);
+ std::size_t expires_after(const duration_type& expiry_time);
+
+ void wait();
+ void wait(boost::system::error_code& ec);
+
+ void async_wait(aux::function<void(boost::system::error_code const&)> handler);
+
+ private:
+
+ void fire(boost::system::error_code ec);
+
+ time_type m_expiration_time;
+ aux::function<void(boost::system::error_code const&)> m_handler;
+ io_context* m_io_service;
+ bool m_expired;
+ };
+
+ using waitable_timer = high_resolution_timer;
+
+ namespace error = boost::asio::error;
+
+ template <typename Protocol>
+ struct socket_base
+ {
+ socket_base(io_context& ios) : m_io_service(ios) {}
+ socket_base(socket_base&& s) = default;
+
+ enum wait_type_t
+ {
+ wait_read, wait_write, wait_error
+ };
+
+ // alias matching the name used by boost.asio's basic_socket::wait_type,
+ // for code that's written against both APIs
+ using wait_type = wait_type_t;
+
+ // io_control
+ using reuse_address = boost::asio::socket_base::reuse_address;
+ using executor_type = io_executor;
+ executor_type get_executor();
+
+ // socket options
+ using send_buffer_size = boost::asio::socket_base::send_buffer_size;
+ using receive_buffer_size = boost::asio::socket_base::receive_buffer_size;
+
+ template <class Option>
+ void set_option(Option const& opt, boost::system::error_code&)
+ {
+ Protocol const p = Protocol::v4();
+ (void)p;
+#ifdef IP_DONTFRAG
+ if (opt.name(p) == IP_DONTFRAG)
+ m_dont_fragment = *reinterpret_cast<int const*>(opt.data(p)) != 0;
+#endif
+#ifdef IP_DONTFRAGMENT
+ if (opt.name(p) == IP_DONTFRAGMENT)
+ m_dont_fragment = *reinterpret_cast<int const*>(opt.data(p)) != 0;
+#endif
+#ifdef IP_MTU_DISCOVER
+ if (opt.name(p) == IP_MTU_DISCOVER)
+ m_dont_fragment = *reinterpret_cast<int const*>(opt.data(p)) == IP_PMTUDISC_DO;
+#endif
+ }
+
+ void set_option(receive_buffer_size const& op, boost::system::error_code&)
+ {
+ m_max_receive_queue_size = op.value();
+ }
+
+ void set_option(send_buffer_size const& op, boost::system::error_code&)
+ {
+ // this limit is specified in microseconds. Given the line rate of
+ // nic_bandwidth, this is the time it takes to send the specified number
+ // of bytes.
+ m_send_queue_time = chrono::microseconds(std::int64_t(double(op.value()) * 1000000.0 / double(aux::nic_bandwidth)));
+ }
+
+ void set_option(reuse_address const&, boost::system::error_code&)
+ {
+ // TODO: implement
+ }
+
+ typename Protocol::endpoint local_endpoint(boost::system::error_code& ec) const
+ {
+ if (!m_open)
+ {
+ ec = error::bad_descriptor;
+ return typename Protocol::endpoint{};
+ }
+
+ return m_user_bound_to;
+ }
+
+ typename Protocol::endpoint local_endpoint() const
+ {
+ boost::system::error_code ec;
+ auto const ret = local_endpoint(ec);
+ if (ec) throw boost::system::system_error(ec);
+ return ret;
+ }
+
+ typename Protocol::endpoint local_bound_to(boost::system::error_code& ec) const
+ {
+ if (!m_open)
+ {
+ ec = error::bad_descriptor;
+ return typename Protocol::endpoint{};
+ }
+
+ return m_bound_to;
+ }
+
+ typename Protocol::endpoint local_bound_to() const
+ {
+ boost::system::error_code ec;
+ auto const ret = local_bound_to(ec);
+ if (ec) throw boost::system::system_error(ec);
+ return ret;
+ }
+
+ template <class Option>
+ void get_option(Option&, boost::system::error_code&) { }
+
+ void get_option(receive_buffer_size& op, boost::system::error_code&)
+ {
+ op = m_max_receive_queue_size;
+ }
+
+ template <class IoControl>
+ void io_control(IoControl const&, boost::system::error_code&) { }
+
+ template <class IoControl>
+ void io_control(IoControl const&) {}
+
+ void non_blocking(bool b, boost::system::error_code&)
+ { m_non_blocking = b; }
+
+ void non_blocking(bool b)
+ { m_non_blocking = b; }
+
+ bool is_open() const
+ {
+ return m_open;
+ }
+
+ using message_flags = int;
+
+ // internal interface
+
+ route get_incoming_route();
+ route get_outgoing_route();
+
+ protected:
+
+ io_context& m_io_service;
+
+ typename Protocol::endpoint m_bound_to;
+
+ // this is the interface the user requested to bind to (in order to
+ // distinguish the concrete interface it was bound to and INADDR_ANY if
+ // that was requested). We keep this separately to return it as the local
+ // endpoint
+ typename Protocol::endpoint m_user_bound_to;
+
+ // this is an object implementing the sink interface, forwarding
+ // packets to this socket. If this socket is destructed, this forwarder
+ // is redirected to just drop packets. This is necessary since sinks
+ // must be held by shared_ptr, and socket objects aren't.
+ std::shared_ptr<aux::sink_forwarder> m_forwarder;
+
+ // whether the socket is open or not
+ bool m_open = false;
+
+ // true if the socket is set to non-blocking mode
+ bool m_non_blocking = false;
+
+ // when true, the MTU limit is in effect
+ bool m_dont_fragment = false;
+
+ // the max size of the incoming queue. This is to emulate the send and
+ // receive buffer. This should also depend on the bandwidth, to not
+ // make the queue size not grow too long in time.
+ int m_max_receive_queue_size = 64 * 1024;
+
+ // the number of microseconds worth of send buffer this socket has, at
+ // NIC linerate.
+ chrono::microseconds m_send_queue_time{200000};
+ };
+
+ namespace ip {
+
+ using boost::asio::ip::address;
+ using boost::asio::ip::address_v4;
+ using boost::asio::ip::address_v6;
+
+ using boost::asio::ip::make_address_v4;
+ using boost::asio::ip::make_address_v6;
+ using boost::asio::ip::make_address;
+
+ using boost::asio::ip::make_network_v4;
+
+ template<typename Protocol>
+ struct basic_endpoint : boost::asio::ip::basic_endpoint<Protocol>
+ {
+ basic_endpoint(ip::address const& addr, unsigned short port)
+ : boost::asio::ip::basic_endpoint<Protocol>(addr, port) {}
+ basic_endpoint() : boost::asio::ip::basic_endpoint<Protocol>() {}
+ };
+
+ template <typename Protocol>
+ struct basic_resolver_entry
+ {
+ using endpoint_type = typename Protocol::endpoint;
+ using protocol_type = Protocol;
+
+ basic_resolver_entry() {}
+ basic_resolver_entry(
+ endpoint_type const& ep
+ , std::string const& host
+ , std::string const& service)
+ : m_endpoint(ep)
+ , m_host_name(host)
+ , m_service(service)
+ {}
+
+ endpoint_type endpoint() const { return m_endpoint; }
+ std::string host_name() const { return m_host_name; }
+ operator endpoint_type() const { return m_endpoint; }
+ std::string service_name() const { return m_service; }
+
+ private:
+ endpoint_type m_endpoint;
+ std::string m_host_name;
+ std::string m_service;
+ };
+
+ template<typename Protocol>
+ struct SIMULATOR_DECL basic_resolver
+ {
+ basic_resolver(io_context& ios);
+
+ using protocol_type = Protocol;
+ using results_type = std::vector<basic_resolver_entry<Protocol>, aux::mallocator<basic_resolver_entry<Protocol>>>;
+
+ void cancel();
+
+ void async_resolve(std::string hostname, char const* service
+ , aux::function<void(boost::system::error_code const&,
+ results_type)> handler);
+
+ basic_resolver(basic_resolver&&) noexcept;
+ basic_resolver& operator=(basic_resolver&&) noexcept;
+ basic_resolver(basic_resolver const&) = delete;
+ basic_resolver& operator=(basic_resolver const&) = delete;
+
+ //TODO: add remaining members
+
+ private:
+
+ void on_lookup(boost::system::error_code const& ec);
+
+ struct result_t
+ {
+ chrono::high_resolution_clock::time_point completion_time;
+ boost::system::error_code err;
+ results_type ips;
+ aux::function<void(boost::system::error_code const&,
+ results_type)> handler;
+
+ result_t(
+ chrono::high_resolution_clock::time_point ct
+ , boost::system::error_code e
+ , results_type ips_
+ , aux::function<void(boost::system::error_code const&
+ , results_type)> h)
+ : completion_time(ct)
+ , err(e)
+ , ips(std::move(ips_))
+ , handler(std::move(h))
+ {}
+
+ result_t(result_t&&) noexcept = default;
+ result_t& operator=(result_t&&) = default;
+ result_t(result_t const&) = delete;
+ result_t& operator=(result_t const&) = delete;
+ };
+
+ io_context* m_ios;
+ asio::high_resolution_timer m_timer;
+ using queue_t = aux::noexcept_movable<std::vector<result_t>>;
+
+ queue_t m_queue;
+ };
+
+ struct SIMULATOR_DECL udp
+ {
+ static udp v4() { return udp(AF_INET); }
+ static udp v6() { return udp(AF_INET6); }
+
+ using endpoint = basic_endpoint<udp>;
+
+ struct SIMULATOR_DECL socket : socket_base<udp>, sink
+ {
+ using endpoint_type = ip::udp::endpoint;
+ using protocol_type = ip::udp;
+ using lowest_layer_type = socket;
+
+ socket(io_context& ios);
+ ~socket() override;
+
+ socket(socket const&) = delete;
+ socket& operator=(socket const&) = delete;
+ socket(socket&&);
+
+ lowest_layer_type& lowest_layer() { return *this; }
+
+ void bind(ip::udp::endpoint const& ep
+ , boost::system::error_code& ec);
+ void bind(ip::udp::endpoint const& ep);
+
+ void close();
+ void close(boost::system::error_code& ec);
+
+ void cancel(boost::system::error_code& ec);
+ void cancel();
+
+ void open(udp protocol, boost::system::error_code& ec);
+ void open(udp protocol);
+
+ template<typename ConstBufferSequence>
+ std::size_t send_to(ConstBufferSequence const& bufs
+ , udp::endpoint const& destination
+ , socket_base::message_flags flags
+ , boost::system::error_code& ec)
+ {
+ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs)
+ , buffer_sequence_end(bufs));
+ abort_send_handlers();
+ return send_to_impl(b, destination, flags, ec);
+ }
+
+ template<typename ConstBufferSequence>
+ std::size_t send_to(ConstBufferSequence const& bufs
+ , udp::endpoint const& destination)
+ {
+ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+ abort_send_handlers();
+ boost::system::error_code ec;
+ std::size_t ret = send_to_impl(b, destination, 0, ec);
+ if (ec) throw boost::system::system_error(ec);
+ return ret;
+ }
+
+ void async_wait(socket_base::wait_type_t w
+ , aux::function<void(boost::system::error_code const&)> handler);
+
+ template <class BufferSequence>
+ void async_receive(BufferSequence const& bufs
+ , aux::function<void(boost::system::error_code const&
+ , std::size_t)> handler)
+ {
+ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+ abort_recv_handlers();
+
+ async_receive_from_impl(b, nullptr, 0, std::move(handler));
+ }
+
+ template <class BufferSequence>
+ void async_receive_from(BufferSequence const& bufs
+ , udp::endpoint& sender
+ , aux::function<void(boost::system::error_code const&
+ , std::size_t)> handler)
+ {
+ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+ abort_recv_handlers();
+
+ async_receive_from_impl(b, &sender, 0, std::move(handler));
+ }
+
+ template <class BufferSequence>
+ void async_receive_from(BufferSequence const& bufs
+ , udp::endpoint& sender
+ , socket_base::message_flags flags
+ , aux::function<void(boost::system::error_code const&
+ , std::size_t)> handler)
+ {
+ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+ abort_recv_handlers();
+
+ async_receive_from_impl(b, &sender, flags, std::move(handler));
+ }
+/*
+ void async_read_from(null_buffers const&
+ , aux::function<void(boost::system::error_code const&
+ , std::size_t)> handler)
+ {
+ abort_recv_handlers();
+ async_read_some_null_buffers_impl(std::move(handler));
+ }
+*/
+
+ template <class BufferSequence>
+ std::size_t receive_from(BufferSequence const& bufs
+ , udp::endpoint& sender)
+ {
+ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+ assert(!b.empty());
+ abort_recv_handlers();
+ boost::system::error_code ec;
+ std::size_t ret = receive_from_impl(b, &sender, 0, ec);
+ if (ec) throw boost::system::system_error(ec);
+ return ret;
+ }
+
+ template <class BufferSequence>
+ std::size_t receive_from(BufferSequence const& bufs
+ , udp::endpoint& sender
+ , socket_base::message_flags)
+ {
+ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+ assert(!b.empty());
+ abort_recv_handlers();
+ boost::system::error_code ec;
+ std::size_t ret = receive_from_impl(b, &sender, 0, ec);
+ if (ec) throw boost::system::system_error(ec);
+ return ret;
+ }
+
+ template <class BufferSequence>
+ std::size_t receive_from(BufferSequence const& bufs
+ , udp::endpoint& sender
+ , socket_base::message_flags
+ , boost::system::error_code& ec)
+ {
+ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+ assert(!b.empty());
+ abort_recv_handlers();
+ return receive_from_impl(b, &sender, 0, ec);
+ }
+
+ // TODO: support connect and remote_endpoint
+
+ // internal interface
+
+ // implements sink
+ virtual void incoming_packet(aux::packet p) override final;
+ virtual std::string label() const override final
+ { return m_bound_to.address().to_string(); }
+
+ void async_receive_from_impl(std::vector<asio::mutable_buffer> const& bufs
+ , udp::endpoint* sender
+ , socket_base::message_flags flags
+ , aux::function<void(boost::system::error_code const&
+ , std::size_t)> handler);
+
+ std::size_t receive_from_impl(
+ std::vector<asio::mutable_buffer> const& bufs
+ , udp::endpoint* sender
+ , socket_base::message_flags flags
+ , boost::system::error_code& ec);
+
+ void async_wait_receive_impl(
+ udp::endpoint* sender
+ , aux::function<void(boost::system::error_code const&)> handler);
+
+ private:
+
+ void maybe_wakeup_reader();
+ void abort_send_handlers();
+ void abort_recv_handlers();
+
+ std::size_t send_to_impl(std::vector<asio::const_buffer> const& b
+ , udp::endpoint const& dst, message_flags flags
+ , boost::system::error_code& ec);
+
+ // this is the next time we'll have an opportunity to send another
+ // outgoing packet. This is used to implement the bandwidth constraints
+ // of channels. This may be in the past, in which case it's OK to send
+ // a packet immediately.
+ chrono::high_resolution_clock::time_point m_next_send;
+
+ // while we're blocked in an async_write_some operation, this is the
+ // handler that should be called once we're done sending
+ aux::function<void(boost::system::error_code const&, std::size_t)>
+ m_send_handler;
+ aux::function<void(boost::system::error_code const&)>
+ m_wait_send_handler;
+
+ // if we have an outstanding read on this socket, this is set to the
+ // handler.
+ aux::function<void(boost::system::error_code const&, std::size_t)>
+ m_recv_handler;
+ aux::function<void(boost::system::error_code const&)>
+ m_wait_recv_handler;
+
+ // if we have an outstanding read operation, this is the buffer to
+ // receive into
+ std::vector<asio::mutable_buffer> m_recv_buffer;
+
+ // if we have an outstanding receive operation, this may point to an
+ // endpoint to fill in the senders IP in
+ udp::endpoint* m_recv_sender;
+
+ asio::high_resolution_timer m_recv_timer;
+ asio::high_resolution_timer m_send_timer;
+
+ // this is the incoming queue of packets for each socket
+ std::list<aux::packet, aux::mallocator<aux::packet>> m_incoming_queue;
+
+ bool m_recv_null_buffers;
+
+ // the number of bytes in the incoming packet queue
+ int m_queue_size;
+
+ // our address family
+ bool m_is_v4;
+ };
+
+ using resolver = basic_resolver<udp>;
+
+ int family() const { return m_family; }
+
+ friend bool operator==(udp const& lhs, udp const& rhs)
+ { return lhs.m_family == rhs.m_family; }
+
+ friend bool operator!=(udp const& lhs, udp const& rhs)
+ { return lhs.m_family != rhs.m_family; }
+
+ private:
+ // Construct with a specific family.
+ explicit udp(int protocol_family)
+ : m_family(protocol_family)
+ {}
+
+ int m_family;
+
+ }; // udp
+
+ struct SIMULATOR_DECL tcp
+ {
+ // temporary fix until the resolvers are implemented using our endpoint
+ tcp(boost::asio::ip::tcp p) : m_family(p.family()) {}
+
+ static tcp v4() { return tcp(AF_INET); }
+ static tcp v6() { return tcp(AF_INET6); }
+
+ int family() const { return m_family; }
+
+ using endpoint = basic_endpoint<tcp>;
+
+ struct SIMULATOR_DECL socket : socket_base<tcp>, sink
+ {
+ using endpoint_type = ip::tcp::endpoint;
+ using protocol_type = ip::tcp;
+ using lowest_layer_type = socket;
+
+ explicit socket(io_context& ios);
+ socket(socket const&) = delete;
+ socket& operator=(socket const&) = delete;
+ socket(socket&&);
+ socket& operator=(socket&&);
+
+ ~socket() override;
+
+ void close();
+ void close(boost::system::error_code& ec);
+ void open(tcp protocol, boost::system::error_code& ec);
+ void open(tcp protocol);
+ void bind(ip::tcp::endpoint const& ep
+ , boost::system::error_code& ec);
+ void bind(ip::tcp::endpoint const& ep);
+ tcp::endpoint remote_endpoint(boost::system::error_code& ec) const;
+ tcp::endpoint remote_endpoint() const;
+
+ lowest_layer_type& lowest_layer() { return *this; }
+
+ void async_connect(tcp::endpoint const& target
+ , aux::function<void(boost::system::error_code const&)> h);
+
+ template <class ConstBufferSequence>
+ void async_write_some(ConstBufferSequence const& bufs
+ , aux::function<void(boost::system::error_code const&
+ , std::size_t)> handler)
+ {
+ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+ abort_send_handlers();
+ async_write_some_impl(b, std::move(handler));
+ }
+
+ void async_wait(socket_base::wait_type_t const w
+ , aux::function<void(boost::system::error_code const&)> handler)
+ {
+ if (w == socket_base::wait_type_t::wait_write)
+ {
+ abort_send_handlers();
+ async_wait_write_impl(std::move(handler));
+ }
+ else if (w == socket_base::wait_type_t::wait_read)
+ {
+ abort_recv_handlers();
+ async_wait_read_impl(std::move(handler));
+ }
+ }
+
+ template <class BufferSequence>
+ std::size_t read_some(BufferSequence const& bufs
+ , boost::system::error_code& ec)
+ {
+ assert(m_non_blocking && "blocking operations not supported");
+ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+ return read_some_impl(b, ec);
+ }
+
+ template <class ConstBufferSequence>
+ std::size_t write_some(ConstBufferSequence const& bufs
+ , boost::system::error_code& ec)
+ {
+ assert(m_non_blocking && "blocking operations not supported");
+ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+ return write_some_impl(b, ec);
+ }
+
+ template <class BufferSequence>
+ void async_read_some(BufferSequence const& bufs
+ , aux::function<void(boost::system::error_code const&
+ , std::size_t)> handler)
+ {
+ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+ abort_recv_handlers();
+
+ async_read_some_impl(b, std::move(handler));
+ }
+
+ std::size_t available(boost::system::error_code & ec) const;
+ std::size_t available() const;
+
+ void cancel(boost::system::error_code& ec);
+ void cancel();
+
+ using socket_base::set_option;
+ using socket_base::get_option;
+ using socket_base::io_control;
+
+ // private interface
+
+ // implements sink
+ virtual void incoming_packet(aux::packet p) override;
+ virtual std::string label() const override final
+ { return m_bound_to.address().to_string(); }
+
+ void internal_connect(tcp::endpoint const& bind_ip
+ , std::shared_ptr<aux::channel> const& c
+ , boost::system::error_code& ec);
+
+ void abort_send_handlers();
+ void abort_recv_handlers();
+
+ virtual bool internal_is_listening();
+ protected:
+
+ void maybe_wakeup_reader();
+ void maybe_wakeup_writer();
+
+ void async_write_some_impl(std::vector<asio::const_buffer> const& bufs
+ , aux::function<void(boost::system::error_code const&, std::size_t)> handler);
+ void async_read_some_impl(std::vector<asio::mutable_buffer> const& bufs
+ , aux::function<void(boost::system::error_code const&, std::size_t)> handler);
+ void async_wait_read_impl(
+ aux::function<void(boost::system::error_code const&)> handler);
+ void async_wait_write_impl(
+ aux::function<void(boost::system::error_code const&)> handler);
+ std::size_t write_some_impl(std::vector<asio::const_buffer> const& bufs
+ , boost::system::error_code& ec);
+ std::size_t read_some_impl(std::vector<asio::mutable_buffer> const& bufs
+ , boost::system::error_code& ec);
+
+ void send_packet(aux::packet p);
+
+ // called when a packet is dropped
+ void packet_dropped(aux::packet p);
+
+ aux::function<void(boost::system::error_code const&)> m_connect_handler;
+
+ asio::high_resolution_timer m_connect_timer;
+
+ // the tcp "packet size" (segment size)
+ // TODO: name this constant!
+ int m_mss = 1475;
+
+ // while we're blocked in an async_write_some operation, this is the
+ // handler that should be called once we're done sending
+ aux::function<void(boost::system::error_code const&, std::size_t)> m_send_handler;
+ aux::function<void(boost::system::error_code const&)> m_wait_send_handler;
+
+ std::vector<asio::const_buffer> m_send_buffer;
+
+ // this is the incoming queue of packets for each socket
+ std::list<aux::packet, aux::mallocator<aux::packet>> m_incoming_queue;
+
+ // the number of bytes in the incoming packet queue
+ int m_queue_size = 0;
+
+ // if we have an outstanding read on this socket, this is set to the
+ // handler.
+ aux::function<void(boost::system::error_code const&, std::size_t)> m_recv_handler;
+ aux::function<void(boost::system::error_code const&)> m_wait_recv_handler;
+
+ // if we have an outstanding buffer to receive into, these are them
+ std::vector<asio::mutable_buffer> m_recv_buffer;
+
+ asio::high_resolution_timer m_recv_timer;
+
+ // our address family
+ bool m_is_v4 = true;
+
+ // true if the currently outstanding read operation is for null_buffers
+ bool m_recv_null_buffers = false;
+
+ // true if the currenly outstanding write operation is for null_buffers
+ bool m_send_null_buffers = false;
+
+ // if this socket is connected to another endpoint, this object is
+ // shared between both sockets and contain information and state about
+ // the channel.
+ std::shared_ptr<aux::channel> m_channel;
+
+ std::uint64_t m_next_outgoing_seq = 0;
+ std::uint64_t m_next_incoming_seq = 0;
+
+ // the sequence number of the last dropped packet. We should only cut
+ // the cwnd in half once per round-trip. If a whole window is lost, we
+ // need to only halve it once
+ std::uint64_t m_last_drop_seq = 0;
+
+ // the current congestion window size (in bytes)
+ int m_cwnd = m_mss * 2;
+
+ // the number of bytes that have been sent but not ACKed yet
+ int m_bytes_in_flight = 0;
+
+ // reorder buffer for when packets are dropped
+ std::map<std::uint64_t, aux::packet, std::less<std::uint64_t>, aux::mallocator<std::pair<std::uint64_t const, aux::packet>>> m_reorder_buffer;
+
+ // the sizes of packets given their sequence number
+ std::unordered_map<std::uint64_t, int, std::hash<std::uint64_t>, std::equal_to<std::uint64_t>, aux::mallocator<std::pair<std::uint64_t const, int>>> m_outstanding_packet_sizes;
+
+ // packets to re-send (because they were dropped)
+ std::list<aux::packet, aux::mallocator<aux::packet>> m_outgoing_packets;
+ };
+
+ struct SIMULATOR_DECL acceptor : socket
+ {
+ explicit acceptor(io_context& ios);
+ acceptor(acceptor&&);
+ ~acceptor() override;
+
+ void cancel(boost::system::error_code& ec);
+ void cancel();
+
+ void listen(int qs = -1);
+ void listen(int qs, boost::system::error_code& ec);
+
+ void async_accept(ip::tcp::socket& peer
+ , aux::function<void(boost::system::error_code const&)> h);
+ void async_accept(ip::tcp::socket& peer
+ , ip::tcp::endpoint& peer_endpoint
+ , aux::function<void(boost::system::error_code const&)> h);
+ void async_accept(aux::function<void(boost::system::error_code const&, ip::tcp::socket peer)> h);
+
+ void close(boost::system::error_code& ec);
+ void close();
+
+ // private interface
+
+ // implements sink
+ virtual void incoming_packet(aux::packet p) override final;
+ virtual bool internal_is_listening() override final;
+
+ private:
+ // check the incoming connection queue to see if any connection in
+ // there is ready to be accepted and delivered to the user
+ void check_accept_queue();
+ void do_check_accept_queue(boost::system::error_code const& ec);
+
+ aux::function<void(boost::system::error_code const&)> m_accept_handler;
+ aux::function<void(boost::system::error_code const&, ip::tcp::socket)> m_accept_handler2;
+
+ // the number of half-open incoming connections this listen socket can
+ // hold. If this is -1, this socket is not yet listening and incoming
+ // connection attempts should be rejected.
+ int m_queue_size_limit;
+
+ // these are incoming connection attempts. Both half-open and
+ // completely connected. When accepting a connection, this queue is
+ // checked first before waiting for a connection attempt.
+ using incoming_conns_t = std::vector<std::shared_ptr<aux::channel>, aux::mallocator<std::shared_ptr<aux::channel>>>;
+ incoming_conns_t m_incoming_conns;
+
+ // for new-style accept, allocate socket in here just to fail early
+ boost::optional<ip::tcp::socket> m_new_socket;
+
+ // the socket to accept a connection into
+ tcp::socket* m_accept_into;
+
+ // the endpoint to write the remote endpoint into when accepting
+ tcp::endpoint* m_remote_endpoint;
+
+ // non copyable
+ acceptor(acceptor const&);
+ acceptor& operator=(acceptor const&);
+ };
+
+ using resolver = basic_resolver<tcp>;
+
+ friend bool operator==(tcp const& lhs, tcp const& rhs)
+ { return lhs.m_family == rhs.m_family; }
+
+ friend bool operator!=(tcp const& lhs, tcp const& rhs)
+ { return lhs.m_family != rhs.m_family; }
+
+ private:
+ // Construct with a specific family.
+ explicit tcp(int protocol_family)
+ : m_family(protocol_family)
+ {}
+
+ int m_family;
+ };
+
+ extern template struct basic_resolver<udp>;
+ extern template struct basic_resolver<tcp>;
+
+ // boost::beast looks up a close function for a socket-like type via
+ // unqualified lookup + ADL under the name "beast_close_socket" (see
+ // boost/beast/core/stream_traits.hpp); this satisfies that customization
+ // point for tcp::socket - it's just a free function beast's ADL-based
+ // lookup will find because it lives in tcp::socket's own namespace, so
+ // beast::websocket::stream<tcp::socket> doesn't need this header to
+ // declare it inside boost::beast itself.
+ inline void beast_close_socket(tcp::socket& s)
+ {
+ boost::system::error_code ec;
+ s.close(ec);
+ }
+
+ // same idea for the teardown()/async_teardown() customization points
+ // boost::beast::websocket::stream<Socket> looks up (via ADL, from
+ // boost::beast::websocket) for any Socket type it's instantiated over
+ // that isn't a boost::asio socket -- see
+ // boost/beast/websocket/teardown.hpp. tcp::socket has no half-close/
+ // non-blocking read-drain support to mirror the real graceful-shutdown
+ // sequence those implement for a real socket, so this just closes it;
+ // that's sufficient for driving deterministic test scenarios, which is
+ // the only thing this socket type is ever used for.
+ inline void teardown(boost::beast::role_type, tcp::socket& s, boost::system::error_code& ec)
+ {
+ s.close(ec);
+ }
+
+ template <class Handler>
+ void async_teardown(boost::beast::role_type, tcp::socket& s, Handler&& handler)
+ {
+ boost::system::error_code ec;
+ s.close(ec);
+ boost::asio::post(s.get_executor(), std::bind(std::forward<Handler>(handler), ec));
+ }
+
+ } // ip
+
+ // mirrors (a subset of) boost::asio::async_connect(socket, begin, end,
+ // handler): tries each endpoint in the range in turn, closing and
+ // advancing to the next on failure, until one connects or the range is
+ // exhausted. Calls handler(error_code, Iterator) with the iterator that
+ // succeeded, or the end iterator carrying the last endpoint's error if
+ // all of them failed. Lives directly in sim::asio, alongside the
+ // boost::asio free function it mirrors, rather than in sim::asio::ip, so
+ // that unqualified calls resolve to whichever of the two applies via
+ // ADL (ip::tcp::socket's base, socket_base<tcp>, is declared in this
+ // namespace, which is what makes that lookup work).
+ template <typename Iterator, typename Handler>
+ void async_connect(ip::tcp::socket& s, Iterator begin, Iterator end, Handler handler)
+ {
+ struct op : std::enable_shared_from_this<op>
+ {
+ op(ip::tcp::socket& sock, Iterator b, Iterator e, Handler h)
+ : socket(sock), iter(b), end(e), handler(std::move(h))
+ {}
+
+ void attempt()
+ {
+ socket.async_connect(*iter, [self = this->shared_from_this()]
+ (boost::system::error_code const& ec) { self->on_connect(ec); });
+ }
+
+ void on_connect(boost::system::error_code const& ec)
+ {
+ if (ec && std::next(iter) != end)
+ {
+ boost::system::error_code ignore;
+ socket.close(ignore);
+ ++iter;
+ attempt();
+ return;
+ }
+
+ handler(ec, iter);
+ }
+
+ ip::tcp::socket& socket;
+ Iterator iter;
+ Iterator end;
+ Handler handler;
+ };
+
+ if (begin == end)
+ {
+ handler(boost::asio::error::make_error_code(boost::asio::error::not_found), end);
+ return;
+ }
+
+ std::make_shared<op>(s, begin, end, std::move(handler))->attempt();
+ }
+
+ } // asio
+
+ struct SIMULATOR_DECL simulation
+ {
+ // it calls fire() when a timer fires
+ friend struct high_resolution_timer;
+
+ simulation(configuration& config);
+ ~simulation();
+
+ std::size_t run();
+
+ std::size_t poll(boost::system::error_code& ec);
+ std::size_t poll();
+
+ std::size_t poll_one(boost::system::error_code& ec);
+ std::size_t poll_one();
+
+ void stop();
+ bool stopped() const;
+ void restart();
+ // private interface
+
+ void add_timer(asio::high_resolution_timer* t);
+ void remove_timer(asio::high_resolution_timer* t);
+
+ boost::asio::io_context& get_internal_service()
+ { return m_service; }
+
+ asio::io_context& get_io_context()
+ { return *m_internal_ios; }
+
+ asio::ip::tcp::endpoint bind_socket(asio::ip::tcp::socket* socket
+ , asio::ip::tcp::endpoint ep
+ , boost::system::error_code& ec);
+ void unbind_socket(asio::ip::tcp::socket* socket
+ , asio::ip::tcp::endpoint const& ep);
+ void rebind_socket(asio::ip::tcp::socket* prev, asio::ip::tcp::socket* s, asio::ip::tcp::endpoint ep);
+
+ asio::ip::udp::endpoint bind_udp_socket(asio::ip::udp::socket* socket
+ , asio::ip::udp::endpoint ep
+ , boost::system::error_code& ec);
+ void unbind_udp_socket(asio::ip::udp::socket* socket
+ , asio::ip::udp::endpoint const& ep);
+ void rebind_udp_socket(asio::ip::udp::socket* socket, asio::ip::udp::endpoint ep);
+
+ std::shared_ptr<aux::channel> internal_connect(asio::ip::tcp::socket* s
+ , asio::ip::tcp::endpoint const& target, boost::system::error_code& ec);
+
+ route find_udp_socket(
+ asio::ip::udp::socket const& socket
+ , asio::ip::udp::endpoint const& ep);
+
+ configuration& config() const { return m_config; }
+
+ void add_io_service(asio::io_context* ios);
+ void remove_io_service(asio::io_context* ios);
+ std::vector<asio::io_context*> get_all_io_services() const;
+
+ aux::pcap* get_pcap() const { return m_pcap.get(); }
+ void log_pcap(char const* filename);
+
+ private:
+ struct timer_compare
+ {
+ bool operator()(asio::high_resolution_timer const* lhs
+ , asio::high_resolution_timer const* rhs) const
+ { return lhs->expiry() < rhs->expiry(); }
+ };
+
+ configuration& m_config;
+
+ std::unique_ptr<aux::pcap> m_pcap;
+
+ // all non-expired timers
+ std::mutex m_timer_queue_mutex;
+ using timer_queue_t = std::vector<asio::high_resolution_timer*, aux::mallocator<asio::high_resolution_timer*>>;
+ timer_queue_t m_timer_queue;
+
+ // these are the io services that represent nodes on the network
+ std::unordered_set<asio::io_context*, std::hash<asio::io_context*>, std::equal_to<asio::io_context*>, aux::mallocator<asio::io_context*>> m_nodes;
+
+ using listen_sockets_t = std::map<asio::ip::tcp::endpoint, asio::ip::tcp::socket*>;
+ using listen_socket_iter_t = listen_sockets_t::iterator;
+ listen_sockets_t m_listen_sockets;
+
+ using udp_sockets_t = std::map<asio::ip::udp::endpoint, asio::ip::udp::socket*>;
+ using udp_socket_iter_t = udp_sockets_t::iterator;
+ udp_sockets_t m_udp_sockets;
+
+ // used for internal timers. this is a pimpl sine our io_context is
+ // incomplete at this point
+ std::unique_ptr<asio::io_context> m_internal_ios;
+
+ // the next port to use for an outgoing connection, where the port is not
+ // specified. We want this to be as unique as possible, to distinguish the
+ // TCP streams.
+ std::uint16_t m_next_bind_port = 2000;
+
+ bool m_stopped = false;
+
+ // underlying message queue
+ boost::asio::io_context m_service;
+ };
+
+ namespace asio {
+
+ using boost::asio::async_write;
+ using boost::asio::async_read;
+
+ // boost.asio compatible io_context class that simulates the network
+ // and time.
+ struct SIMULATOR_DECL io_context : boost::asio::execution_context
+ {
+ io_context(sim::simulation& sim);
+ io_context(sim::simulation& sim, ip::address const& ip);
+ io_context(sim::simulation& sim, std::vector<ip::address> const& ips);
+ io_context(std::size_t threads_hint = 0);
+ ~io_context();
+
+ // not copyable and non movable (it's not movable because we currently
+ // keep pointers to the io_context instances in the simulator object)
+ io_context(io_context const&) = delete;
+ io_context(io_context&&) = delete;
+ io_context& operator=(io_context const&) = delete;
+ io_context& operator=(io_context&&) = delete;
+
+ std::size_t run(boost::system::error_code& ec);
+ std::size_t run();
+
+ std::size_t poll(boost::system::error_code& ec);
+ std::size_t poll();
+
+ std::size_t poll_one(boost::system::error_code& ec);
+ std::size_t poll_one();
+
+ template <typename Rep, typename Period>
+ std::size_t run_for(std::chrono::duration<Rep, Period> const&)
+ {
+ assert(false);
+ return 0;
+ }
+
+ template <typename Rep, typename Period>
+ std::size_t poll_one_for(std::chrono::duration<Rep, Period> const&)
+ {
+ assert(false);
+ return 0;
+ }
+
+ void stop();
+ bool stopped() const;
+ void restart();
+
+ template <typename Handler, typename Allocator>
+ void dispatch_impl(Handler handler, Allocator const& a)
+ { get_internal_service().get_executor().dispatch(std::move(handler), a); }
+
+ template <typename Handler, typename Allocator>
+ void post_impl(Handler handler, Allocator const& a)
+ { get_internal_service().get_executor().post(std::move(handler), a); }
+
+ template <typename Handler, typename Allocator>
+ void defer_impl(Handler handler, Allocator const& a)
+ { get_internal_service().get_executor().defer(std::move(handler), a); }
+
+ // internal interface
+ boost::asio::io_context& get_internal_service();
+
+ void add_timer(high_resolution_timer* t);
+ void remove_timer(high_resolution_timer* t);
+
+ ip::tcp::endpoint bind_socket(ip::tcp::socket* socket, ip::tcp::endpoint ep
+ , boost::system::error_code& ec);
+ void unbind_socket(ip::tcp::socket* socket
+ , ip::tcp::endpoint const& ep);
+ void rebind_socket(asio::ip::tcp::socket* prev, asio::ip::tcp::socket* s, asio::ip::tcp::endpoint ep);
+
+ ip::udp::endpoint bind_udp_socket(ip::udp::socket* socket, ip::udp::endpoint ep
+ , boost::system::error_code& ec);
+ void unbind_udp_socket(ip::udp::socket* socket
+ , ip::udp::endpoint const& ep);
+ void rebind_udp_socket(asio::ip::udp::socket* socket, asio::ip::udp::endpoint ep);
+
+ std::shared_ptr<aux::channel> internal_connect(ip::tcp::socket* s
+ , ip::tcp::endpoint const& target, boost::system::error_code& ec);
+
+ route find_udp_socket(asio::ip::udp::socket const& socket
+ , ip::udp::endpoint const& ep);
+
+ route const& get_outgoing_route(ip::address ip) const
+ { return m_outgoing_route.find(ip)->second; }
+
+ route const& get_incoming_route(ip::address ip) const
+ { return m_incoming_route.find(ip)->second; }
+
+ int get_path_mtu(const asio::ip::address& source, const asio::ip::address& dest) const;
+ std::vector<ip::address> const& get_ips() const { return m_ips; }
+
+ sim::simulation& sim() { return m_sim; }
+
+ using executor_type = io_executor;
+ executor_type get_executor() { return executor_type(*this); }
+
+ private:
+
+ sim::simulation& m_sim;
+ std::vector<ip::address> m_ips;
+
+ // these are determined by the configuration. They may include NATs and
+ // DSL modems (queues)
+ std::map<ip::address, route> m_outgoing_route;
+ std::map<ip::address, route> m_incoming_route;
+
+ bool m_stopped = false;
+ };
+
+ template <typename Handler, typename Allocator>
+ void io_executor::dispatch(Handler handler, Allocator const& a) const
+ { m_ctx->dispatch_impl(std::move(handler), a); }
+
+ template <typename Handler, typename Allocator>
+ void io_executor::post(Handler handler, Allocator const& a) const
+ { m_ctx->post_impl(std::move(handler), a); }
+
+ template <typename Handler, typename Allocator>
+ void io_executor::defer(Handler handler, Allocator const& a) const
+ { m_ctx->defer_impl(std::move(handler), a); }
+
+ template <typename Protocol>
+ io_executor
+ socket_base<Protocol>::get_executor()
+ { return io_executor(m_io_service); }
+
+ template <typename Protocol>
+ route socket_base<Protocol>::get_incoming_route()
+ {
+ route ret = m_io_service.get_incoming_route(m_bound_to.address());
+ assert(m_forwarder);
+ ret.append(std::static_pointer_cast<sim::sink>(m_forwarder));
+ return ret;
+ }
+
+ template <typename Protocol>
+ route socket_base<Protocol>::get_outgoing_route()
+ {
+ return route(m_io_service.get_outgoing_route(m_bound_to.address()));
+ }
+
+ } // asio
+
+ // user supplied configuration of the network to simulate
+ struct SIMULATOR_DECL configuration
+ {
+ virtual ~configuration() {}
+
+ // build the network
+ virtual void build(simulation& sim) = 0;
+
+ // return the hops on the network packets from src to dst need to traverse
+ virtual route channel_route(asio::ip::address src
+ , asio::ip::address dst) = 0;
+
+ // return the hops an incoming packet to ep need to traverse before
+ // reaching the socket (for instance a NAT)
+ virtual route incoming_route(asio::ip::address ip) = 0;
+
+ // return the hops an outgoing packet from ep need to traverse before
+ // reaching the network (for instance a DSL modem)
+ virtual route outgoing_route(asio::ip::address ip) = 0;
+
+ // return the path MTU between the two IP addresses
+ // For TCP sockets, this will be called once when the connection is
+ // established. For UDP sockets it's called for every burst of packets
+ // that are sent
+ virtual int path_mtu(asio::ip::address ip1, asio::ip::address ip2) = 0;
+
+ // called for every hostname lookup made by the client. ``reqyestor`` is
+ // the node performing the lookup, ``hostname`` is the name being looked
+ // up. Resolve the name into addresses and fill in ``result`` or set
+ // ``ec`` if the hostname is not found or some other error occurs. The
+ // return value is the latency of the lookup. The client's callback won't
+ // be called until after waiting this long.
+ virtual chrono::high_resolution_clock::duration hostname_lookup(
+ asio::ip::address const& requestor
+ , std::string hostname
+ , std::vector<asio::ip::address>& result
+ , boost::system::error_code& ec) = 0;
+
+ virtual void clear() = 0;
+ };
+
+ struct SIMULATOR_DECL default_config : configuration
+ {
+ default_config() : m_sim(nullptr) {}
+
+ void build(simulation& sim) override;
+ route channel_route(asio::ip::address src, asio::ip::address dst) override;
+ route incoming_route(asio::ip::address ip) override;
+ route outgoing_route(asio::ip::address ip) override;
+ int path_mtu(asio::ip::address ip1, asio::ip::address ip2) override;
+ chrono::high_resolution_clock::duration hostname_lookup(
+ asio::ip::address const& requestor
+ , std::string hostname
+ , std::vector<asio::ip::address>& result
+ , boost::system::error_code& ec) override;
+
+ void clear() override;
+ protected:
+ std::shared_ptr<queue> m_network;
+ std::map<asio::ip::address, std::shared_ptr<queue>> m_incoming;
+ std::map<asio::ip::address, std::shared_ptr<queue>> m_outgoing;
+ simulation* m_sim;
+ };
+
+ namespace aux
+ {
+ /* the channel can be in the following states:
+ 1. handshake-1 - the initiating socket has sent SYN
+ 2. handshake-2 - the accepting connection has sent SYN+ACK
+ 3. handshake-3 - the initiating connection has received the SYN+ACK and
+ considers the connection open, but the 3rd handshake
+ message is still in flight.
+ 4. connected - the accepting side has received the 3rd handshake
+ packet and considers it open
+
+ Whenever a connection attempt is made to a listening socket, as long as
+ there is still space in the incoming socket queue, the accepting side
+ will always respond immediately and complete the handshake, then wait
+ until the user calls async_accept (which in this case would complete
+ immediately).
+ */
+ struct SIMULATOR_DECL channel
+ {
+ channel() {}
+ // index 0 is the incoming route to the socket that initiated the connection.
+ // index 1 may be empty while the connection is half-open
+ route hops[2];
+
+ // the actual endpoint of each end of the channel
+ asio::ip::tcp::endpoint ep[2];
+
+ // observable endpoint of each side of the channel. This is not how you
+ // see yourself, just the other end
+ asio::ip::tcp::endpoint visible_ep[2];
+
+ // the number of bytes sent from respective direction
+ // this is used to simulate the TCP sequence number, so it deliberately
+ // is meant to wrap at 32 bits
+ std::uint32_t bytes_sent[2];
+
+ int remote_idx(asio::ip::tcp::endpoint const& self) const;
+ int self_idx(asio::ip::tcp::endpoint const& self) const;
+ };
+
+ } // aux
+
+ void SIMULATOR_DECL dump_network_graph(simulation const& s, const std::string& filename);
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif // SIMULATOR_HPP_INCLUDED
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef SINK_HPP_INCLUDED
+#define SINK_HPP_INCLUDED
+
+#include "simulator/config.hpp"
+#include <string>
+
+namespace sim {
+
+namespace aux {
+ struct packet;
+}
+
+ // this is an interface for somthing that can accept incoming packets,
+ // such as queues, sockets, NATs and TCP congestion windows
+ struct SIMULATOR_DECL sink
+ {
+ virtual void incoming_packet(aux::packet p) = 0;
+
+ // used for visualization
+ virtual std::string label() const = 0;
+
+ virtual std::string attributes() const { return "shape=box"; }
+ virtual ~sink() = default;
+ };
+
+} // sim
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef SINK_FORWARDER_HPP_INCLUDED
+#define SINK_FORWARDER_HPP_INCLUDED
+
+#include "simulator/config.hpp"
+#include "simulator/sink.hpp"
+
+namespace sim { namespace aux {
+
+ struct packet;
+
+ struct SIMULATOR_DECL sink_forwarder final : sink
+ {
+ sink_forwarder(sink* dst);
+ void incoming_packet(packet p) override;
+ std::string label() const override;
+ void reset(sink* s = nullptr);
+
+ private:
+ sink* m_dst;
+ };
+
+}} // sim
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef SOCKS_SERVER_HPP_INCLUDED
+#define SOCKS_SERVER_HPP_INCLUDED
+
+#include "simulator/simulator.hpp"
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#if __GNUC__ >= 9
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+#endif
+
+#include <boost/bimap.hpp>
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push)
+// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
+#pragma warning( disable : 4251)
+#endif
+
+namespace sim
+{
+
+enum socks_flag
+{
+ // when this flag is set, the proxy will close the client connection
+ // immediately after sending the response to a UDP ASSOCIATE command
+ disconnect_udp_associate = 1,
+
+ // when this flag is set, the reponse to UDP ASSOCIATE will contain an empty
+ // hostname, rather than the relay IP address
+ udp_associate_respond_empty_hostname = 2
+};
+
+struct SIMULATOR_DECL socks_connection : std::enable_shared_from_this<socks_connection>
+{
+ socks_connection(asio::io_context& ios, int version, std::array<int, 3>& cmd_counts
+ , std::uint32_t flags, int& bind_port);
+
+ asio::ip::tcp::socket& socket() { return m_client_connection; }
+
+ void start();
+
+private:
+
+ void on_handshake1(boost::system::error_code const& ec, size_t bytes_transferred);
+ void on_handshake2(boost::system::error_code const& ec, size_t bytes_transferred);
+ void on_handshake3(boost::system::error_code const& ec, size_t bytes_transferred);
+ void on_request1(boost::system::error_code const& ec, size_t bytes_transferred);
+ void on_request2(boost::system::error_code const& ec, size_t bytes_transferred);
+
+ void on_write(boost::system::error_code const& ec, size_t bytes_transferred
+ , bool close);
+ void close_connection();
+
+ int format_response(asio::ip::address const& addr, int port, int response);
+ int format_hostname_response(char const* hostname, int port, int response);
+
+ void on_connected(boost::system::error_code const& ec);
+ void on_request_domain_name(boost::system::error_code const& ec, size_t bytes_transferred);
+ void on_request_domain_lookup(boost::system::error_code const& ec
+ , const asio::ip::tcp::resolver::results_type ips);
+
+ void open_forward_connection(asio::ip::tcp::endpoint const& target);
+ void bind_connection(asio::ip::tcp::endpoint const& target);
+ void start_accept(boost::system::error_code const& ec);
+
+ void udp_associate(asio::ip::tcp::endpoint const& target);
+ void on_read_udp(boost::system::error_code const& ec, std::size_t bytes_transferred);
+ void wait_for_eof(boost::system::error_code const& ec, std::size_t bytes_transferred);
+
+ void on_server_receive(boost::system::error_code const& ec
+ , std::size_t bytes_transferred);
+ void on_server_forward(boost::system::error_code const& ec
+ , size_t bytes_transferred);
+
+ void on_client_receive(boost::system::error_code const& ec
+ , std::size_t bytes_transferred);
+ void on_client_forward(boost::system::error_code const& ec
+ , size_t bytes_transferred);
+
+ char const* command() const;
+
+ int& m_bind_port;
+
+ asio::io_context& m_ios;
+
+ asio::ip::udp::resolver m_udp_resolver;
+
+ asio::ip::tcp::resolver m_resolver;
+
+ boost::bimap<asio::ip::address, std::string> m_name_mapping;
+
+ // this is the SOCKS client connection, i.e. the client connecting to us and
+ // being forwarded
+ asio::ip::tcp::socket m_client_connection;
+
+ // this is the connection to the server the socks client is being forwarded
+ // to
+ asio::ip::tcp::socket m_server_connection;
+ asio::ip::tcp::acceptor m_bind_socket;
+
+ asio::ip::udp::socket m_udp_associate;
+ asio::ip::udp::endpoint m_udp_associate_ep;
+ asio::ip::udp::endpoint m_udp_from;
+
+ std::array<char, 1500> m_udp_buffer;
+
+ // receive buffer for data going out, i.e. client -> proxy (us) -> server
+ char m_out_buffer[65536];
+ // buffer size
+ int m_num_out_bytes;
+
+ // receive buffer for data coming in, i.e. server -> proxy (us) -> client
+ char m_in_buffer[65536];
+ // buffer size
+ int m_num_in_bytes;
+
+ // set to true when shutting down
+ bool m_close = false;
+
+ // the SOCKS protocol version (4 or 5)
+ const int m_version;
+
+ int m_command;
+
+ std::array<int, 3>& m_cmd_counts;
+
+ std::uint32_t const m_flags;
+};
+
+// This is a very simple socks4 and 5 server that only supports a single
+// concurrent connection
+struct SIMULATOR_DECL socks_server
+{
+ socks_server(asio::io_context& ios, unsigned short listen_port
+ , int version = 5, std::uint32_t flags = 0);
+
+ void stop();
+
+ void bind_start_port(int const port) { m_bind_port = port; }
+
+ // return the number of CONNECT, BIND and UDP_ASSOCIATE commands the proxy
+ // has received
+ std::array<int, 3> cmd_counts() const
+ { return m_cmd_counts; }
+
+private:
+
+ void on_accept(boost::system::error_code const& ec);
+
+ asio::io_context& m_ios;
+
+ asio::ip::tcp::acceptor m_listen_socket;
+
+ std::shared_ptr<socks_connection> m_conn;
+
+ asio::ip::tcp::endpoint m_ep;
+
+ int m_bind_port = 2048;
+
+ // set to true when shutting down
+ bool m_close = false;
+
+ // the SOCKS protocol version (4 or 5)
+ const int m_version;
+
+ std::array<int, 3> m_cmd_counts;
+
+ std::uint32_t const m_flags;
+};
+
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2026, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef SIMULATOR_SSL_HPP_INCLUDED
+#define SIMULATOR_SSL_HPP_INCLUDED
+
+#include "simulator/simulator.hpp"
+
+#include "simulator/push_warnings.hpp"
+#include <boost/asio/ssl.hpp>
+#include "simulator/pop_warnings.hpp"
+
+namespace sim {
+namespace asio {
+
+namespace ssl
+{
+ using boost::asio::ssl::context;
+ using boost::asio::ssl::stream_base;
+ using boost::asio::ssl::verify_context;
+
+ template <typename Stream>
+ using stream = boost::asio::ssl::stream<Stream>;
+} // ssl
+
+} // asio
+} // sim
+
+#endif
--- /dev/null
+/*
+
+Copyright (c) 2016, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#ifndef UTILS_HPP_INCLUDED
+#define UTILS_HPP_INCLUDED
+
+#include "simulator/simulator.hpp"
+
+namespace sim
+{
+
+// shortcut for creating a timer with a timeout and action
+struct timer
+{
+ timer(simulation& sim, chrono::high_resolution_clock::duration timeout
+ , aux::function<void(boost::system::error_code const&)>&& f)
+ : m_ios(sim, asio::ip::address_v4())
+ , m_timer(m_ios)
+ {
+ m_timer.expires_after(timeout);
+ m_timer.async_wait(std::move(f));
+ }
+
+private:
+ sim::asio::io_context m_ios;
+ sim::asio::high_resolution_timer m_timer;
+};
+
+} // sim
+
+#endif
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include "simulator/packet.hpp"
+
+#include <functional>
+#include <boost/beast/core/bind_handler.hpp>
+
+#include <cinttypes>
+
+using boost::beast::bind_handler;
+
+typedef sim::chrono::high_resolution_clock::time_point time_point;
+typedef sim::chrono::high_resolution_clock::duration duration;
+
+namespace sim {
+namespace asio {
+namespace ip {
+
+ tcp::acceptor::acceptor(io_context& ios)
+ : socket(ios)
+ , m_queue_size_limit(-1)
+ {}
+
+ tcp::acceptor::acceptor(acceptor&&) = default;
+
+ tcp::acceptor::~acceptor()
+ {
+ boost::system::error_code ec;
+ close(ec);
+ }
+
+ void tcp::acceptor::listen(int qs)
+ {
+ boost::system::error_code ec;
+ listen(qs, ec);
+ if (ec) throw boost::system::system_error(ec);
+ }
+
+ void tcp::acceptor::listen(int qs, boost::system::error_code& ec)
+ {
+ if (qs == -1) qs = 20;
+
+ if (!m_open)
+ {
+ ec = error::bad_descriptor;
+ return;
+ }
+ if (m_bound_to == ip::tcp::endpoint())
+ {
+ ec = error::invalid_argument;
+ return;
+ }
+
+ m_queue_size_limit = qs;
+ ec.clear();
+ }
+
+ void tcp::acceptor::close(boost::system::error_code& ec)
+ {
+ m_queue_size_limit = -1;
+ cancel(ec);
+ socket::close(ec);
+ }
+
+ void tcp::acceptor::close()
+ {
+ if (m_accept_handler)
+ {
+ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+ , boost::system::error_code(error::operation_aborted)));
+ }
+ if (m_accept_handler2)
+ {
+ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+ h(boost::system::error_code(error::operation_aborted)
+ , ip::tcp::socket(m_io_service));
+ });
+ }
+ }
+
+ void tcp::acceptor::cancel(boost::system::error_code& ec)
+ {
+ ec.clear();
+ if (m_accept_handler)
+ {
+ try
+ {
+ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+ , boost::system::error_code(error::operation_aborted)));
+ }
+ catch (std::bad_alloc const&)
+ {
+ ec = error::no_memory;
+ }
+ catch (std::exception const&)
+ {
+ ec = error::no_memory;
+ }
+ }
+ if (m_accept_handler2)
+ {
+ try
+ {
+ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+ h(boost::system::error_code(error::operation_aborted)
+ , ip::tcp::socket(m_io_service));
+ });
+ }
+ catch (std::bad_alloc const&)
+ {
+ ec = error::no_memory;
+ }
+ catch (std::exception const&)
+ {
+ ec = error::no_memory;
+ }
+ }
+ }
+
+ void tcp::acceptor::cancel()
+ {
+ boost::system::error_code ec;
+ cancel(ec);
+ if (ec) throw boost::system::system_error(ec);
+ }
+
+ void tcp::acceptor::async_accept(ip::tcp::socket& peer
+ , aux::function<void(boost::system::error_code const&)> h)
+ {
+ // TODO: assert that the io_context we use is the same as the one peer use
+ if (peer.is_open())
+ {
+ boost::system::error_code ec;
+ peer.close(ec);
+ }
+
+ if (m_accept_handler)
+ {
+ m_accept_into = nullptr;
+ m_remote_endpoint = nullptr;
+ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+ , boost::system::error_code(error::operation_aborted)));
+ }
+ if (m_accept_handler2)
+ {
+ m_accept_into = nullptr;
+ m_remote_endpoint = nullptr;
+ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+ h(boost::system::error_code(error::operation_aborted)
+ , ip::tcp::socket(m_io_service));
+ });
+ }
+ m_accept_handler = std::move(h);
+ m_accept_into = &peer;
+ m_remote_endpoint = nullptr;
+
+ check_accept_queue();
+ }
+
+ void tcp::acceptor::async_accept(ip::tcp::socket& peer
+ , ip::tcp::endpoint& peer_endpoint
+ , aux::function<void(boost::system::error_code const&)> h)
+ {
+ if (peer.is_open())
+ {
+ boost::system::error_code ec;
+ peer.close(ec);
+ }
+
+ if (m_accept_handler)
+ {
+ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+ , boost::system::error_code(error::operation_aborted)));
+ }
+ if (m_accept_handler2)
+ {
+ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+ h(boost::system::error_code(error::operation_aborted)
+ , ip::tcp::socket(m_io_service));
+ });
+ }
+ m_accept_handler = std::move(h);
+ m_accept_into = &peer;
+ m_remote_endpoint = &peer_endpoint;
+
+ check_accept_queue();
+ }
+
+ void tcp::acceptor::async_accept(aux::function<void(boost::system::error_code const&, ip::tcp::socket peer)> h)
+ {
+ m_remote_endpoint = nullptr;
+ if (m_accept_handler)
+ {
+ m_accept_into = nullptr;
+ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+ , boost::system::error_code(error::operation_aborted)));
+ }
+ if (m_accept_handler2)
+ {
+ m_accept_into = nullptr;
+ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+ h(boost::system::error_code(error::operation_aborted)
+ , ip::tcp::socket(m_io_service));
+ });
+ }
+ m_new_socket.emplace(m_io_service);
+ m_accept_handler2 = std::move(h);
+ m_accept_into = &*m_new_socket;
+
+ check_accept_queue();
+ }
+
+ void tcp::acceptor::do_check_accept_queue(boost::system::error_code const& ec)
+ {
+ if (ec) return;
+ check_accept_queue();
+ }
+
+ void tcp::acceptor::incoming_packet(aux::packet p)
+ {
+ switch (p.type)
+ {
+ case aux::packet::type_t::syn:
+ m_incoming_conns.push_back(p.channel);
+ check_accept_queue();
+ return;
+ case aux::packet::type_t::error:
+ assert(false); // something is not wired up correctly
+ if (m_accept_handler)
+ {
+ m_accept_into = nullptr;
+ m_remote_endpoint = nullptr;
+ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+ , boost::system::error_code(error::operation_aborted)));
+ }
+ if (m_accept_handler2)
+ {
+ m_accept_into = nullptr;
+ m_remote_endpoint = nullptr;
+ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+ h(boost::system::error_code(error::operation_aborted)
+ , ip::tcp::socket(m_io_service));
+ });
+ }
+ return;
+ default:
+ // if this happens, it implies that an incoming connection sent
+ // payload before receiving a syn_ack. Alternatively that the
+ // acceptor sent the syn_ack but still left the last-hop in the
+ // incoming route to point to this socket, instead of the
+ // accepted-into socket
+ assert(false);
+ return;
+ }
+ }
+
+ void tcp::acceptor::check_accept_queue()
+ {
+ if (!is_open())
+ {
+ // if the acceptor socket is closed. Any potential socket in the queue
+ // should be closed too.
+ for (auto const& incoming : m_incoming_conns)
+ {
+ aux::packet p;
+ p.from = asio::ip::udp::endpoint(
+ m_bound_to.address(), m_bound_to.port());
+ p.type = aux::packet::type_t::error;
+ p.ec = boost::system::error_code(error::connection_reset);
+ p.overhead = 28;
+ p.hops = incoming->hops[0];
+
+ forward_packet(std::move(p));
+ }
+ m_incoming_conns.clear();
+
+ if (m_accept_handler)
+ {
+ m_accept_into = nullptr;
+ m_remote_endpoint = nullptr;
+ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+ , boost::system::error_code(error::operation_aborted)));
+ }
+ if (m_accept_handler2)
+ {
+ m_accept_into = nullptr;
+ m_remote_endpoint = nullptr;
+ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+ h(boost::system::error_code(error::operation_aborted)
+ , ip::tcp::socket(m_io_service));
+ });
+ }
+ }
+
+ // if the user is not waiting for an incoming connection, there's no point
+ // in checking the queue
+ if (!m_accept_handler && !m_accept_handler2) return;
+
+ if (m_incoming_conns.empty()) return;
+
+ std::shared_ptr<aux::channel> c = std::move(m_incoming_conns.front());
+ m_incoming_conns.erase(m_incoming_conns.begin());
+
+ // this was initiated at least one 3-way handshake ago.
+ // we can pick it up and consider it connected
+ if (m_remote_endpoint) *m_remote_endpoint = c->ep[0];
+ m_remote_endpoint = nullptr;
+
+ boost::system::error_code ec;
+ // if the acceptor socket is closed. Any potential socket in the queue
+ m_accept_into->internal_connect(m_bound_to, c, ec);
+
+ // notify the other end
+ aux::packet p;
+ p.from = asio::ip::udp::endpoint(m_bound_to.address(), m_bound_to.port());
+ if (ec)
+ {
+ c->hops[1] = route();
+ p.type = aux::packet::type_t::error;
+ p.ec = ec;
+ }
+ else
+ {
+ // TODO: extend pcap logging to include SYN+ACK packets
+ p.type = aux::packet::type_t::syn_ack;
+ }
+ p.channel = c;
+ p.overhead = 28;
+ p.hops = p.channel->hops[0];
+
+ forward_packet(std::move(p));
+
+ try
+ {
+ if (m_accept_handler)
+ {
+ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr), ec));
+ }
+ else if (m_accept_handler2)
+ {
+ post(m_io_service, bind_handler(std::exchange(m_accept_handler2, nullptr)
+ , ec, std::move(*m_accept_into)));
+ }
+ }
+ catch (...)
+ {
+ m_new_socket.reset();
+ m_accept_into = nullptr;
+ throw;
+ }
+ m_new_socket.reset();
+ m_accept_into = nullptr;
+ }
+
+ bool tcp::acceptor::internal_is_listening()
+ {
+ return m_queue_size_limit > 0;
+ }
+}
+}
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include "simulator/queue.hpp"
+#include <memory>
+
+typedef sim::chrono::high_resolution_clock::time_point time_point;
+typedef sim::chrono::high_resolution_clock::duration duration;
+using sim::asio::ip::address_v4;
+using sim::asio::ip::address_v6;
+using sim::asio::ip::address;
+using sim::chrono::milliseconds;
+using sim::chrono::duration_cast;
+
+namespace sim {
+
+ void default_config::build(simulation& sim)
+ {
+ // 0 bandwidth and 0 queue means infinite. The network itself only adds
+ // 50 ms latency
+ m_network = std::make_shared<queue>(std::ref(sim.get_io_context())
+ , 0, duration_cast<duration>(milliseconds(30)), 0, "network");
+ m_sim = ∼
+ }
+
+ void default_config::clear()
+ {
+ m_network.reset();
+ m_outgoing.clear();
+ m_incoming.clear();
+ }
+
+ route default_config::channel_route(
+ asio::ip::address /* src */
+ , asio::ip::address /* dst */)
+ {
+ return route().append(m_network);
+ }
+
+ route default_config::incoming_route(asio::ip::address ip)
+ {
+ // incoming download rate is 800kB/s with a 200 kB queue
+ // and 1 ms forwarding delay
+ auto it = m_incoming.find(ip);
+ if (it != m_incoming.end()) return route().append(it->second);
+ it = m_incoming.insert(it, std::make_pair(ip, std::make_shared<queue>(
+ std::ref(m_sim->get_io_context()), 800 * 1000
+ , duration_cast<duration>(milliseconds(1)), 200 * 1000, "DSL modem in")));
+ return route().append(it->second);
+ }
+
+ int default_config::path_mtu(
+ asio::ip::address /* ip1 */
+ , asio::ip::address /* ip2 */)
+ {
+ return 1475;
+ }
+
+ // return the hops an outgoing packet from ep need to traverse before
+ // reaching the network (for instance a DSL modem)
+ route default_config::outgoing_route(asio::ip::address ip)
+ {
+ // outgoing upload rate is 200kB/s with a 200 kB queue
+ // and 1 ms forwarding delay
+ auto it = m_outgoing.find(ip);
+ if (it != m_outgoing.end()) return route().append(it->second);
+ it = m_outgoing.insert(it, std::make_pair(ip, std::make_shared<queue>(
+ std::ref(m_sim->get_io_context()), 200 * 1000
+ , duration_cast<duration>(milliseconds(1)), 200 * 1000, "DSL modem out")));
+ return route().append(it->second);
+ }
+
+ duration default_config::hostname_lookup(
+ asio::ip::address const& /* requestor */
+ , std::string hostname
+ , std::vector<asio::ip::address>& result
+ , boost::system::error_code& ec)
+ {
+ if (hostname == "localhost")
+ {
+ result = { asio::ip::make_address_v6("::1")
+ , asio::ip::make_address_v4("127.0.0.1") };
+ return duration_cast<duration>(chrono::microseconds(1));
+ }
+
+ ec = boost::system::error_code(asio::error::host_not_found);
+ return duration_cast<duration>(chrono::milliseconds(100));
+ }
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+
+#include <functional>
+
+#include "simulator/push_warnings.hpp"
+#include <boost/system/error_code.hpp>
+#include "simulator/pop_warnings.hpp"
+
+namespace sim { namespace chrono {
+ namespace {
+
+ // this is the global simulation timer
+ high_resolution_clock::time_point g_simulation_time;
+ }
+
+ high_resolution_clock::time_point high_resolution_clock::now()
+ {
+ return g_simulation_time;
+ }
+
+ void high_resolution_clock::fast_forward(high_resolution_clock::duration d)
+ {
+ g_simulation_time += d;
+ }
+
+ void reset_clock()
+ {
+ g_simulation_time = high_resolution_clock::time_point{};
+ }
+
+} // chrono
+} // sim
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include "simulator/handler_allocator.hpp"
+
+#include <functional>
+#include <boost/system/error_code.hpp>
+
+namespace sim
+{
+
+ namespace asio {
+
+ high_resolution_timer::high_resolution_timer(io_context& ioc)
+ : m_expiration_time(time_type())
+ , m_io_service(&ioc)
+ , m_expired(true)
+ {
+ }
+
+ high_resolution_timer::high_resolution_timer(io_context& ioc,
+ const time_type& expiry_time)
+ : m_expiration_time(time_type())
+ , m_io_service(&ioc)
+ , m_expired(true)
+ {
+ expires_at(expiry_time);
+ }
+
+ high_resolution_timer::high_resolution_timer(io_context& ioc,
+ const duration_type& expiry_time)
+ : m_expiration_time(time_type())
+ , m_io_service(&ioc)
+ , m_expired(true)
+ {
+ expires_after(expiry_time);
+ }
+
+ high_resolution_timer::~high_resolution_timer()
+ {
+ cancel();
+ }
+
+ std::size_t high_resolution_timer::cancel()
+ {
+ if (m_expired) return 0;
+ m_expired = true;
+ m_io_service->remove_timer(this);
+ if (!m_handler) return 0;
+ fire(boost::asio::error::operation_aborted);
+ return 1;
+ }
+
+ std::size_t high_resolution_timer::cancel_one()
+ {
+ // TODO: support multiple handlers
+ return cancel();
+ }
+
+ high_resolution_timer::time_type high_resolution_timer::expiry() const
+ { return m_expiration_time; }
+
+ std::size_t high_resolution_timer::expires_at(high_resolution_timer::time_type const& expiry_time)
+ {
+ std::size_t ret = cancel();
+ m_expiration_time = expiry_time;
+ m_expired = false;
+ m_io_service->add_timer(this);
+ return ret;
+ }
+
+ std::size_t high_resolution_timer::expires_after(const duration_type& expiry_time)
+ {
+ std::size_t ret = cancel();
+ m_expiration_time = chrono::high_resolution_clock::now() + expiry_time;
+ m_expired = false;
+ m_io_service->add_timer(this);
+ return ret;
+ }
+
+ void high_resolution_timer::wait()
+ {
+ assert(false && "can't use synchcronous calls in simulator");
+ boost::system::error_code ec;
+ wait(ec);
+ }
+
+ void high_resolution_timer::wait(boost::system::error_code&)
+ {
+ assert(false && "can't use synchcronous calls in simulator");
+ time_type now = chrono::high_resolution_clock::now();
+ if (now >= m_expiration_time) return;
+ chrono::high_resolution_clock::fast_forward(m_expiration_time - now);
+ }
+
+ void high_resolution_timer::async_wait(aux::function<void(boost::system::error_code const&)> handler)
+ {
+ // TODO: support multiple handlers
+ assert(!m_handler);
+ m_handler = std::move(handler);
+ if (m_expired)
+ {
+ fire(boost::system::error_code());
+ return;
+ }
+ }
+
+ void high_resolution_timer::fire(boost::system::error_code ec)
+ {
+ m_expired = true;
+ if (!m_handler) return;
+ auto h = std::move(m_handler);
+ m_handler = nullptr;
+ post(*m_io_service, make_malloc(std::bind(std::move(h), ec)));
+ }
+
+ high_resolution_timer::executor_type high_resolution_timer::get_executor()
+ {
+ return (*m_io_service).get_executor();
+ }
+
+ } // asio
+
+} // sim
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include "simulator/http_proxy.hpp"
+#include "simulator/http_server.hpp" // for helper functions
+
+#include <functional>
+#include <cstdio> // for printf
+
+using namespace sim::asio;
+using namespace sim::asio::ip;
+using namespace std::placeholders;
+
+using boost::system::error_code;
+
+namespace sim
+{
+ using namespace aux;
+
+ http_proxy::http_proxy(io_context& ios, unsigned short const listen_port)
+ : m_resolver(ios)
+ , m_listen_socket(ios)
+ , m_client_connection(ios)
+ , m_server_connection(ios)
+ , m_writing_to_server(false)
+ , m_num_client_in_bytes(0)
+ , m_num_server_out_bytes(0)
+ , m_num_in_bytes(0)
+ , m_close(false)
+ {
+ address local_ip = ios.get_ips().front();
+ if (local_ip.is_v4())
+ {
+ m_listen_socket.open(tcp::v4());
+ m_listen_socket.bind(tcp::endpoint(address_v4::any(), listen_port));
+ }
+ else
+ {
+ m_listen_socket.open(tcp::v6());
+ m_listen_socket.bind(tcp::endpoint(address_v6::any(), listen_port));
+ }
+ m_listen_socket.listen();
+
+ m_listen_socket.async_accept(m_client_connection, m_ep
+ , std::bind(&http_proxy::on_accept, this, _1));
+ }
+
+ void http_proxy::on_accept(error_code const& ec)
+ {
+ if (ec == asio::error::operation_aborted)
+ return;
+
+ if (ec)
+ {
+ std::printf("http_proxy::on_accept: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ std::printf("http_proxy accepted connection from: %s : %d\n",
+ m_ep.address().to_string().c_str(), m_ep.port());
+
+ // read http request
+ m_client_connection.async_read_some(asio::buffer(
+ &m_client_in_buffer[0], sizeof(m_client_in_buffer))
+ , std::bind(&http_proxy::on_read_request, this, _1, _2));
+ }
+
+ void http_proxy::on_read_request(error_code const& ec, size_t bytes_transferred) try
+ {
+ if (ec)
+ {
+ std::printf("http_proxy::on_read_request: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ m_num_client_in_bytes += int(bytes_transferred);
+
+ // scan for end of HTTP request
+ int req_len = find_request_len(m_client_in_buffer, m_num_client_in_bytes);
+ while (req_len >= 0)
+ {
+ // parse request from [0, eor), connect to target server and forward
+ // the request.
+ http_request const req = parse_request(m_client_in_buffer, req_len);
+ forward_request(req);
+
+ // pop this request from the receive buffer
+ memmove(m_client_in_buffer, m_client_in_buffer + req_len
+ , m_num_client_in_bytes - req_len);
+ m_num_client_in_bytes -= req_len;
+
+ // is there another request in the buffer?
+ req_len = find_request_len(m_client_in_buffer, m_num_client_in_bytes);
+ }
+
+ // read more from the client
+ m_client_connection.async_read_some(asio::buffer(
+ &m_client_in_buffer[m_num_client_in_bytes]
+ , sizeof(m_client_in_buffer) - m_num_client_in_bytes)
+ , std::bind(&http_proxy::on_read_request, this, _1, _2));
+ }
+ catch (std::runtime_error& e)
+ {
+ std::printf("http_proxy::on_read_request() failed: %s\n"
+ , e.what());
+ close_connection();
+ }
+
+ void http_proxy::forward_request(http_request const& req)
+ {
+ std::string out_request;
+ out_request = req.method;
+ out_request += ' ';
+ if (req.req.compare(0, 7, "http://") != 0)
+ {
+ std::printf("http_proxy::forward_request: expected full URL in request, got: %s\n"
+ , req.req.c_str());
+ throw std::runtime_error("invalid request");
+ }
+
+ std::string::size_type const path_start = req.req.find_first_of('/', 7);
+ if (path_start == std::string::npos) out_request += '/';
+ else out_request.append(req.req, path_start, std::string::npos);
+ out_request += " HTTP/1.1\r\n";
+
+ std::string::size_type const host_end = req.req.substr(0, path_start).find_last_of(':');
+
+ std::string host = req.req.substr(7, (host_end != std::string::npos && host_end > 7)
+ ? host_end - 7 : path_start - 7);
+
+ // if the hostname is an IPv6 address, strip the brackets around it to
+ // make it parse correctly
+ if (host.size() >= 2 && host.front() == '[' && host.back() == ']')
+ host = host.substr(1, host.size() - 2);
+
+ int const port = host_end == std::string::npos || host_end <= 7 ? 80
+ : atoi(req.req.substr(host_end + 1, path_start).c_str());
+ assert(port >= 0 && port < 0xffff);
+
+ bool found_host = false;
+ for (auto const& h : req.headers)
+ {
+ if (h.first == "host") found_host = true;
+
+ out_request += h.first;
+ out_request += ": ";
+ out_request += h.second;
+ out_request += "\r\n";
+ }
+ if (!found_host)
+ {
+ out_request += "host: ";
+ out_request += host;
+ out_request += "\r\n";
+ }
+ out_request += "\r\n";
+
+ if (m_num_server_out_bytes + out_request.size() > sizeof(m_server_out_buffer))
+ {
+ std::printf("http_proxy: Too many queued server requests: %d bytes\n"
+ , int(m_num_server_out_bytes + out_request.size()));
+ throw std::runtime_error("pipeline too deep");
+ }
+ memmove(&m_server_out_buffer[m_num_server_out_bytes]
+ , out_request.data(), out_request.size());
+ m_num_server_out_bytes += int(out_request.size());
+
+ if (!m_server_connection.is_open())
+ {
+ boost::system::error_code err;
+ tcp::endpoint target(make_address(host.c_str(), err)
+ , static_cast<unsigned short>(port));
+ if (err)
+ {
+ char port_str[10];
+ std::snprintf(port_str, sizeof(port_str), "%d", port);
+ m_resolver.async_resolve(host, port_str
+ , std::bind(&http_proxy::on_domain_lookup, this, _1, _2));
+ return;
+ }
+ open_forward_connection(target);
+ return;
+ }
+
+ // TODO: make sure we're connecting/connected to the same (host, port)
+ // that this request is for. Don't support multiple servers
+
+ write_server_send_buffer();
+ }
+
+ void http_proxy::on_domain_lookup(boost::system::error_code const& ec
+ , const asio::ip::tcp::resolver::results_type ips)
+ {
+ if (ec || ips.empty())
+ {
+ if (ec)
+ {
+ std::printf("http_proxy::on_domain_lookup: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ }
+ else
+ {
+ std::printf("http_proxy::on_request_domain_lookup: empty response\n");
+ }
+ error(503, "Resource Temporarily Unavailable");
+ return;
+ }
+ open_forward_connection(ips.front().endpoint());
+ }
+
+ void http_proxy::open_forward_connection(const asio::ip::tcp::endpoint& target)
+ {
+ m_server_connection.open(target.protocol());
+
+ std::printf("http_proxy: async_connect: %s:%d\n"
+ , target.address().to_string().c_str(), target.port());
+ m_server_connection.async_connect(target
+ , std::bind(&http_proxy::on_connected, this, _1));
+ }
+
+ void http_proxy::error(int code, char const* message)
+ {
+ std::string send_buffer = send_response(code, message);
+ memcpy(m_in_buffer, send_buffer.data(), send_buffer.size());
+ asio::async_write(m_client_connection, asio::buffer(
+ &m_in_buffer[0], send_buffer.size())
+ , std::bind(&http_proxy::close_connection, this));
+ }
+
+ void http_proxy::on_connected(boost::system::error_code const& ec)
+ {
+ if (ec)
+ {
+ std::printf("http_proxy::on_connected() connection failed: %s\n", ec.message().c_str());
+ m_server_connection.close();
+ error(503, "Service Temporarily Unavailable");
+ return;
+ }
+
+ std::printf("http_proxy: connected\n");
+
+ write_server_send_buffer();
+
+ m_server_connection.async_read_some(
+ asio::buffer(m_in_buffer, sizeof(m_in_buffer))
+ , std::bind(&http_proxy::on_server_receive, this, _1, _2));
+ }
+
+ void http_proxy::write_server_send_buffer()
+ {
+ if (m_writing_to_server) return;
+ m_writing_to_server = true;
+ m_server_connection.async_write_some(asio::buffer(
+ &m_server_out_buffer[0], m_num_server_out_bytes)
+ , std::bind(&http_proxy::on_server_write, this, _1, _2));
+ }
+
+ void http_proxy::on_server_write(error_code const& ec, size_t bytes_transferred)
+ {
+ m_writing_to_server = false;
+ if (ec)
+ {
+ std::printf("http_proxy::on_server_write: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ memmove(&m_server_out_buffer[0], &m_server_out_buffer[bytes_transferred]
+ , m_num_server_out_bytes - bytes_transferred);
+ m_num_server_out_bytes -= int(bytes_transferred);
+
+ if (m_num_server_out_bytes > 0)
+ write_server_send_buffer();
+ }
+
+ // we received some data from the server, forward it to the server
+ void http_proxy::on_server_receive(boost::system::error_code const& ec
+ , std::size_t bytes_transferred)
+ {
+ if (ec)
+ {
+ std::printf("http_proxy: error reading from server: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], bytes_transferred)
+ , std::bind(&http_proxy::on_server_forward, this, _1, _2));
+ }
+
+ void http_proxy::on_server_forward(error_code const& ec
+ , size_t)
+ {
+ if (ec)
+ {
+ std::printf("http_proxy: error writing to client: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ m_server_connection.async_read_some(
+ sim::asio::buffer(m_in_buffer, sizeof(m_in_buffer))
+ , std::bind(&http_proxy::on_server_receive, this, _1, _2));
+ }
+
+ void http_proxy::stop()
+ {
+ m_close = true;
+ m_listen_socket.close();
+ }
+
+ void http_proxy::close_connection()
+ {
+ m_num_client_in_bytes = 0;
+ m_num_server_out_bytes = 0;
+ m_num_in_bytes = 0;
+
+ error_code err;
+ m_client_connection.close(err);
+ if (err)
+ {
+ std::printf("http_proxy::close: failed to close client connection (%d) %s\n"
+ , err.value(), err.message().c_str());
+ }
+ m_server_connection.close(err);
+ if (err)
+ {
+ std::printf("http_proxy::close: failed to close server connection (%d) %s\n"
+ , err.value(), err.message().c_str());
+ }
+
+ if (m_close) return;
+
+ // now we can accept another connection
+ m_listen_socket.async_accept(m_client_connection, m_ep
+ , std::bind(&http_proxy::on_accept, this, _1));
+ }
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include "simulator/http_server.hpp"
+
+#include <functional>
+#include <cstdio> // for printf
+
+using namespace sim::asio;
+using namespace sim::asio::ip;
+using namespace std::placeholders;
+
+using boost::system::error_code;
+
+namespace sim
+{
+ using namespace aux;
+
+ namespace {
+ char const* find(char const* hay, int const hsize
+ , char const* needle, int const nsize)
+ {
+ for (int i = 0; i < hsize - nsize + 1; ++i)
+ {
+ if (memcmp(hay + i, needle, nsize) == 0) return hay + i;
+ }
+ return nullptr;
+ }
+ }
+
+ std::string trim(std::string s)
+ {
+ if (s.empty()) return s;
+
+ int start = 0;
+ int end = int(s.size());
+ while (strchr(" \r\n\t", s[start]) != NULL && start < end)
+ {
+ ++start;
+ }
+
+ while (strchr(" \r\n\t", s[end-1]) != NULL && end > start)
+ {
+ --end;
+ }
+ return s.substr(start, end - start);
+ }
+
+ std::string lower_case(std::string s)
+ {
+ std::string ret;
+ std::transform(s.begin(), s.end(), std::back_inserter(ret)
+ , [](char c) { return static_cast<char>(tolower(c)); } );
+ return ret;
+ }
+
+ std::string normalize(const std::string& s)
+ {
+ std::vector<std::string> elements;
+ char const* start = s.c_str();
+ if (*start == '/') ++start;
+ char const* slash = strchr(start, '/');
+ while (slash != NULL)
+ {
+ std::string element(start, slash - start);
+ if (element != "..")
+ {
+ elements.push_back(element);
+ } else if (!elements.empty())
+ {
+ elements.erase(elements.end()-1);
+ }
+ start = slash + 1;
+ slash = strchr(start, '/');
+ }
+ elements.push_back(start);
+
+ std::string ret;
+ for (auto const& e : elements)
+ {
+ ret += '/';
+ ret += e;
+ }
+
+ return ret;
+ }
+
+ // TODO: extra_header should be a std::vector
+ std::string send_response(int code, char const* status_message
+ , int len, char const** extra_header)
+ {
+ std::string ret = "HTTP/1.1 " + std::to_string(code) + " " + status_message + "\r\n";
+
+ ret += "content-length: " + std::to_string(len) + "\r\n";
+
+ if (extra_header)
+ {
+ ret += extra_header[0];
+ ret += extra_header[1];
+ ret += extra_header[2];
+ ret += extra_header[3];
+ }
+ ret += "\r\n";
+
+ return ret;
+ }
+
+ http_server::http_server(io_context& ios, unsigned short listen_port, int flags)
+ : m_ios(ios)
+ , m_listen_socket(ios)
+ , m_connection(ios)
+ , m_bytes_used(0)
+ , m_close(false)
+ , m_flags(flags)
+ {
+ address local_ip = ios.get_ips().front();
+ if (local_ip.is_v4())
+ {
+ m_listen_socket.open(tcp::v4());
+ m_listen_socket.bind(tcp::endpoint(address_v4::any(), listen_port));
+ }
+ else
+ {
+ m_listen_socket.open(tcp::v6());
+ m_listen_socket.bind(tcp::endpoint(address_v6::any(), listen_port));
+ }
+ m_listen_socket.listen();
+
+ m_listen_socket.async_accept(m_connection, m_ep
+ , std::bind(&http_server::on_accept, this, _1));
+ }
+
+ void http_server::on_accept(error_code const& ec)
+ {
+ if (ec)
+ {
+ std::printf("http_server::on_accept: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ ++m_accepted_connections;
+
+ std::printf("http_server accepted connection from: %s : %d\n",
+ m_ep.address().to_string().c_str(), m_ep.port());
+
+ read();
+ }
+
+ void http_server::register_handler(std::string const& path, handler_t h)
+ {
+ m_handlers[path] = std::move(h);
+ }
+
+ void http_server::register_content(std::string const& path
+ , std::int64_t const size, generator_t gen)
+ {
+ m_handlers[path] = [gen,size](std::string, std::string, std::map<std::string, std::string>& hdr)
+ {
+ std::int64_t start = 0;
+ std::int64_t end = size;
+
+ auto it = hdr.find("range");
+ bool const range_req = it != hdr.end();
+ if (range_req)
+ {
+ std::string range = it->second;
+ // skip "bytes "
+ range = range.substr(range.find_first_of('=') + 1);
+ start = std::stoll(range.substr(0, range.find('-')));
+ end = std::stoll(range.substr(range.find_first_of('-') + 1)) + 1;
+ }
+
+ std::string header = "Content-Range: bytes " + std::to_string(start)
+ + "-" + std::to_string(end-1) + "/" + std::to_string(end-start) + "\r\n";
+ char const* extra_headers[4] = { header.c_str(), "", "", ""};
+
+ return sim::send_response(range_req ? 206 : 200
+ , range_req ? "Partial Content" : "OK"
+ , int(end - start), range_req ? extra_headers : nullptr)
+ + gen(start, end - start);
+ };
+ }
+
+ void http_server::register_redirect(std::string const& path, std::string const& target)
+ {
+ m_handlers[path] = [target](std::string, std::string, std::map<std::string, std::string>&)
+ {
+ std::string header = "Location: " + target + "\r\n";
+ char const* extra_headers[4] = { header.c_str(), "", "", ""};
+ return sim::send_response(301, "Moved Permanently", 0, extra_headers);
+ };
+ }
+
+ void http_server::register_stall_handler(std::string const& path){
+ m_stall_handlers.insert(path);
+ }
+
+ void http_server::read()
+ {
+ if (m_bytes_used >= int(m_recv_buffer.size()) / 2)
+ {
+ m_recv_buffer.resize((std::max)(500, m_bytes_used * 2));
+ }
+ assert(int(m_recv_buffer.size()) > m_bytes_used);
+ m_connection.async_read_some(asio::buffer(&m_recv_buffer[m_bytes_used]
+ , m_recv_buffer.size() - m_bytes_used)
+ , std::bind(&http_server::on_read, this, _1, _2));
+ }
+
+ http_request parse_request(char const* start, int len)
+ {
+ http_request ret;
+
+ char const* const end_of_request = start + len;
+ char const* const space = find(start, len, " ", 1);
+ if (space == nullptr)
+ {
+ std::printf("http_server: failed to parse request:\n%s\n"
+ , std::string(start, len).c_str());
+ throw std::runtime_error("parse failed");
+ }
+
+ char const* const space2 = find(space + 1
+ , int(len - (space - start + 1)), " ", 1);
+ if (space2 == nullptr)
+ {
+ std::printf("http_server: failed to parse request:\n%s\n"
+ , std::string(start, len).c_str());
+ throw std::runtime_error("parse failed");
+ }
+ ret.method.assign(start, space);
+ ret.req.assign(space+1, space2);
+ if (ret.method != "CONNECT") {
+ ret.path.assign(normalize(ret.req.substr(0, ret.req.find_first_of('?'))));
+ } else {
+ ret.path.assign(ret.req);
+ }
+ std::printf("parse_request: %s %s [%s]\n"
+ , ret.method.c_str(), ret.path.c_str(), ret.req.c_str());
+
+ char const* header = find(space2, int(len - (space2 - start)), "\r\n", 2);
+ while (header != end_of_request - 4)
+ {
+ if (header == nullptr)
+ {
+ std::printf("http_server: failed to parse request:\n%s\n"
+ , std::string(start, len).c_str());
+ throw std::runtime_error("parse failed");
+ }
+ char const* const next = find(header + 2
+ , int(len - (header + 2 - start)), "\r\n", 2);
+ char const* const value = static_cast<char const*>(memchr(header, ':', len - (header - start)));
+ if (value == nullptr || next == nullptr || value > next)
+ {
+ std::printf("http_server: failed to parse request:\n%s\n"
+ , std::string(start, len).c_str());
+ throw std::runtime_error("parse failed");
+ }
+
+ ret.headers[lower_case(trim(std::string(header, value)))]
+ = trim(std::string(value+1, next));
+
+ header = next;
+ }
+ return ret;
+ }
+
+ int find_request_len(char const* buf, int const len)
+ {
+ char const* end_of_request = find(buf, len, "\r\n\r\n", 4);
+ if (end_of_request == nullptr) return -1;
+ return int(end_of_request - buf + 4);
+ }
+
+ void http_server::on_read(error_code const& ec, size_t bytes_transferred) try
+ {
+ if (ec)
+ {
+ std::printf("http_server::on_read: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ m_bytes_used += int(bytes_transferred);
+
+ int const req_len = find_request_len(m_recv_buffer.data(), m_bytes_used);
+ if (req_len < 0)
+ {
+ read();
+ return;
+ }
+
+ http_request req = parse_request(m_recv_buffer.data(), req_len);
+
+ m_recv_buffer.erase(m_recv_buffer.begin(), m_recv_buffer.begin() + req_len);
+ m_bytes_used -= req_len;
+
+ auto it = m_handlers.find(req.path);
+ if (it == m_handlers.end())
+ {
+ if (m_stall_handlers.find(req.path) != m_stall_handlers.end())
+ {
+ return;
+ }
+ // no handler found, 404
+ m_send_buffer = send_response(404, "Not Found");
+ }
+ else
+ {
+ m_send_buffer = it->second(req.method, req.req, req.headers);
+ }
+
+ // decide whether to close the connection after this response, and signal
+ // it to the client appropriately.
+ bool close;
+ if (m_flags & http_1_0)
+ {
+ // an HTTP/1.0 server closes after every response and does not use the
+ // Connection header (that is an HTTP/1.1 mechanism). Downgrade the
+ // status line so the client detects this from the protocol version.
+ close = true;
+ auto const ver = m_send_buffer.find("HTTP/1.1");
+ if (ver != std::string::npos)
+ m_send_buffer.replace(ver, 8, "HTTP/1.0");
+ }
+ else
+ {
+ // close if the client asked us to, or if this server is not
+ // configured for keep-alive. When we do, advertise it with a
+ // "Connection: close" response header so the client knows not to
+ // reuse the socket (rather than discovering it via a failed write).
+ close = lower_case(req.headers["connection"]) == "close"
+ || !(m_flags & keep_alive);
+ if (close)
+ {
+ auto const status_end = m_send_buffer.find("\r\n");
+ if (status_end != std::string::npos)
+ {
+ assert(m_send_buffer.find("Connection:") == std::string::npos);
+ m_send_buffer.insert(status_end + 2, "Connection: close\r\n");
+ }
+ }
+ }
+
+ async_write(m_connection, asio::buffer(m_send_buffer.data()
+ , m_send_buffer.size()), std::bind(&http_server::on_write
+ , this, _1, _2, close));
+ }
+ catch (std::exception& e)
+ {
+ std::printf("http_server::on_read() failed: %s\n"
+ , e.what());
+ close_connection();
+ }
+
+ void http_server::on_write(error_code const& ec
+ , size_t /* bytes_transferred */
+ , bool close)
+ {
+ if (ec)
+ {
+ std::printf("http_server::on_write: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ if (!close)
+ {
+ // try to read another request out of the buffer
+ post(m_ios, std::bind(&http_server::on_read, this, error_code(), 0));
+ }
+ else
+ {
+ close_connection();
+ }
+ }
+
+ void http_server::stop()
+ {
+ m_close = true;
+ m_listen_socket.close();
+ }
+
+ void http_server::close_connection()
+ {
+ m_recv_buffer.clear();
+ m_bytes_used = 0;
+
+ error_code err;
+ m_connection.close(err);
+ if (err)
+ {
+ std::printf("http_server::close: failed to close connection (%d) %s\n"
+ , err.value(), err.message().c_str());
+ return;
+ }
+
+ if (m_close) return;
+
+ // now we can accept another connection
+ m_listen_socket.async_accept(m_connection, m_ep
+ , std::bind(&http_server::on_accept, this, _1));
+ }
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+
+#include <boost/make_shared.hpp>
+#include <boost/system/error_code.hpp>
+
+namespace sim { namespace asio {
+
+ io_context::io_context(sim::simulation& sim)
+ : io_context(sim, std::vector<asio::ip::address>())
+ {}
+
+ io_context::io_context(sim::simulation& sim, asio::ip::address const& ip)
+ : io_context(sim, std::vector<asio::ip::address>{ip})
+ {}
+
+ io_context::io_context(sim::simulation& sim, std::vector<asio::ip::address> const& ips)
+ : m_sim(sim)
+ , m_ips(ips)
+ , m_stopped(false)
+ {
+ for (auto const& ip : m_ips)
+ {
+ m_outgoing_route[ip] = m_sim.config().outgoing_route(ip);
+ m_incoming_route[ip] = m_sim.config().incoming_route(ip);
+ }
+ m_sim.add_io_service(this);
+ }
+
+ io_context::~io_context()
+ {
+ m_sim.remove_io_service(this);
+ }
+
+ // this constructor is never meant to be called (hence the assert). It only
+ // exists to satisfy interfaces that require a default-like constructor. The
+ // null reference is deliberate, so suppress the warning about it.
+#if defined __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wnull-dereference"
+#elif defined __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wnull-dereference"
+#endif
+ io_context::io_context(std::size_t)
+ : m_sim(*reinterpret_cast<sim::simulation*>(0))
+ {
+ assert(false);
+ }
+#if defined __clang__
+#pragma clang diagnostic pop
+#elif defined __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+ int io_context::get_path_mtu(const asio::ip::address& source, const asio::ip::address& dest) const
+ {
+ // TODO: it would be nice to actually traverse the virtual network nodes
+ // and ask for their MTU instead
+ assert(std::count(m_ips.begin(), m_ips.end(), source) > 0 && "source address must be a local address to this node/io_context");
+ return m_sim.config().path_mtu(source, dest);
+ }
+
+ void io_context::stop()
+ {
+ // TODO: cancel all outstanding handler associated with this io_context
+ m_stopped = true;
+ }
+
+ bool io_context::stopped() const
+ {
+ return m_stopped;
+ }
+
+ void io_context::restart()
+ {
+ m_stopped = false;
+ }
+
+ std::size_t io_context::run()
+ {
+ assert(false);
+ return 0;
+ }
+
+ std::size_t io_context::run(boost::system::error_code&)
+ {
+ assert(false);
+ return 0;
+ }
+
+ std::size_t io_context::poll()
+ {
+ assert(false);
+ return 0;
+ }
+
+ std::size_t io_context::poll(boost::system::error_code&)
+ {
+ assert(false);
+ return 0;
+ }
+
+ std::size_t io_context::poll_one()
+ {
+ assert(false);
+ return 0;
+ }
+
+ std::size_t io_context::poll_one(boost::system::error_code&)
+ {
+ assert(false);
+ return 0;
+ }
+
+ // private interface
+
+ void io_context::add_timer(high_resolution_timer* t)
+ {
+ m_sim.add_timer(t);
+ }
+
+ void io_context::remove_timer(high_resolution_timer* t)
+ {
+ m_sim.remove_timer(t);
+ }
+
+ boost::asio::io_context& io_context::get_internal_service()
+ { return m_sim.get_internal_service(); }
+
+ ip::tcp::endpoint io_context::bind_socket(ip::tcp::socket* socket
+ , ip::tcp::endpoint ep, boost::system::error_code& ec)
+ {
+ assert(!m_ips.empty() && "you cannot use an internal io_context (one without an IP address) for creating and binding sockets");
+ if (ep.address() == ip::address_v4::any())
+ {
+ auto it = std::find_if(m_ips.begin(), m_ips.end()
+ , [](ip::address const& ip) { return ip.is_v4(); } );
+ if (it == m_ips.end())
+ {
+ ec.assign(boost::system::errc::address_not_available
+ , boost::system::generic_category());
+ return ip::tcp::endpoint();
+ }
+ // TODO: pick the first local endpoint for now. In the future we may
+ // want have a bias toward
+ ep.address(*it);
+ }
+ else if (ep.address() == ip::address_v6::any())
+ {
+ auto it = std::find_if(m_ips.begin(), m_ips.end()
+ , [](ip::address const& ip) { return ip.is_v6(); } );
+ if (it == m_ips.end())
+ {
+ ec.assign(boost::system::errc::address_not_available
+ , boost::system::generic_category());
+ return ip::tcp::endpoint();
+ }
+ // TODO: pick the first local endpoint for now. In the future we may
+ // want have a bias toward
+ ep.address(*it);
+ }
+ else if (std::count(m_ips.begin(), m_ips.end(), ep.address()) == 0)
+ {
+ // you can only bind to the IP assigned to this node.
+ // TODO: support loopback
+ ec.assign(boost::system::errc::address_not_available
+ , boost::system::generic_category());
+ return ip::tcp::endpoint();
+ }
+
+ return m_sim.bind_socket(socket, ep, ec);
+ }
+
+ void io_context::unbind_socket(ip::tcp::socket* socket
+ , const ip::tcp::endpoint& ep)
+ {
+ m_sim.unbind_socket(socket, ep);
+ }
+
+ void io_context::rebind_socket(asio::ip::tcp::socket* prev, asio::ip::tcp::socket* s, asio::ip::tcp::endpoint ep)
+ {
+ m_sim.rebind_socket(prev, s, ep);
+ }
+
+ ip::udp::endpoint io_context::bind_udp_socket(ip::udp::socket* socket
+ , ip::udp::endpoint ep, boost::system::error_code& ec)
+ {
+ assert(!m_ips.empty() && "you cannot use an internal io_context (one without an IP address) for creating and binding sockets");
+ if (ep.address() == ip::address_v4::any())
+ {
+ auto it = std::find_if(m_ips.begin(), m_ips.end()
+ , [](ip::address const& ip) { return ip.is_v4(); });
+ if (it == m_ips.end())
+ {
+ ec.assign(boost::system::errc::address_not_available
+ , boost::system::generic_category());
+ return ip::udp::endpoint();
+ }
+ // TODO: pick the first local endpoint for now. In the future we may
+ // want have a bias toward
+ ep.address(*it);
+ }
+ else if (ep.address() == ip::address_v6::any())
+ {
+ auto it = std::find_if(m_ips.begin(), m_ips.end()
+ , [](ip::address const& ip) { return ip.is_v6(); });
+ if (it == m_ips.end())
+ {
+ ec.assign(boost::system::errc::address_not_available
+ , boost::system::generic_category());
+ return ip::udp::endpoint();
+ }
+ // TODO: pick the first local endpoint for now. In the future we may
+ // want have a bias toward
+ ep.address(*it);
+ }
+ else if (std::count(m_ips.begin(), m_ips.end(), ep.address()) == 0)
+ {
+ // you can only bind to the IP assigned to this node.
+ // TODO: support loopback
+ ec.assign(boost::system::errc::address_not_available
+ , boost::system::generic_category());
+ return ip::udp::endpoint();
+ }
+
+ return m_sim.bind_udp_socket(socket, ep, ec);
+ }
+
+ void io_context::unbind_udp_socket(ip::udp::socket* socket
+ , const ip::udp::endpoint& ep)
+ {
+ m_sim.unbind_udp_socket(socket, ep);
+ }
+
+ void io_context::rebind_udp_socket(asio::ip::udp::socket* socket, asio::ip::udp::endpoint ep)
+ {
+ m_sim.rebind_udp_socket(socket, ep);
+ }
+
+ std::shared_ptr<aux::channel> io_context::internal_connect(ip::tcp::socket* s
+ , ip::tcp::endpoint const& target, boost::system::error_code& ec)
+ {
+ return m_sim.internal_connect(s, target, ec);
+ }
+
+ route io_context::find_udp_socket(asio::ip::udp::socket const& socket
+ , ip::udp::endpoint const& ep)
+ {
+ return m_sim.find_udp_socket(socket, ep);
+ }
+
+} // asio
+} // sim
+
--- /dev/null
+/*
+
+Copyright (c) 2018, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/nat.hpp"
+#include "simulator/simulator.hpp"
+#include "simulator/packet.hpp"
+#include <string>
+
+namespace sim {
+
+ nat::nat(asio::ip::address external_addr) : m_external_addr(external_addr) {}
+
+ void nat::incoming_packet(aux::packet p)
+ {
+ // unconditionally replacing the "from" address is fine because of our
+ // simplified network model where the two paths of a connection are set up
+ // independently, and we can set up the nat hop only on the outgoing path
+ p.from.address(m_external_addr);
+ if (p.channel) {
+ p.channel->visible_ep[0].address(m_external_addr);
+ }
+ forward_packet(std::move(p));
+ }
+
+ // used for visualization
+ std::string nat::label() const
+ {
+ return std::string("NAT [") + m_external_addr.to_string() + "]";
+ }
+
+} // sim
+
--- /dev/null
+/*
+
+Copyright (c) 2017, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/pcap.hpp"
+#include "simulator/chrono.hpp"
+#include "simulator/packet.hpp"
+
+using sim::chrono::duration_cast;
+using sim::chrono::seconds;
+
+using sim::asio::ip::address_v4;
+using sim::asio::ip::tcp;
+using sim::asio::ip::udp;
+
+namespace sim { namespace aux {
+
+namespace {
+
+ template <typename T, typename cond = typename std::enable_if<std::is_pod<T>::value>::type>
+ void write(std::fstream& o, T const& value)
+ { o.write(reinterpret_cast<char const*>(&value), sizeof(value)); }
+
+ // documented here:
+ // http://www.tcpdump.org/linktypes.html
+ std::uint32_t const LINKTYPE_RAW = 101;
+
+ struct ip_header
+ {
+ std::uint8_t version_len;
+ std::uint8_t dscp;
+ std::uint16_t length;
+ std::uint16_t identification;
+ std::uint16_t fragment;
+ std::uint8_t ttl;
+ std::uint8_t protocol;
+ std::uint16_t checksum;
+ std::uint32_t source_ip;
+ std::uint32_t destination_ip;
+ };
+
+ struct udp_header
+ {
+ std::uint16_t src_port;
+ std::uint16_t dst_port;
+ std::uint16_t length;
+ std::uint16_t checksum;
+ };
+
+ struct tcp_header
+ {
+ std::uint16_t src_port;
+ std::uint16_t dst_port;
+ std::uint32_t seq_nr;
+ std::uint32_t ack_nr;
+ std::uint8_t offset;
+ std::uint8_t flags;
+ std::uint16_t window_size;
+ std::uint16_t checksum;
+ std::uint16_t urgent;
+ };
+}
+
+ pcap::pcap(char const* filename)
+ : m_file(filename, std::ios_base::out | std::ios_base::trunc | std::ios_base::binary)
+ {
+ // file format documented here:
+ // https://wiki.wireshark.org/Development/LibpcapFileFormat
+ // write pcap file header
+ write(m_file, std::uint32_t(0xa1b2c3d4)); // magic number
+ write(m_file, std::uint16_t(2)); // versopm major
+ write(m_file, std::uint16_t(4)); // versopm minor
+ write(m_file, std::int32_t(0)); // thiszone
+ write(m_file, std::uint32_t(0)); // sigfigs
+ write(m_file, std::uint32_t(0xffff)); // snaplen
+ write(m_file, LINKTYPE_RAW); // network
+ }
+
+ void write_ip_header(std::fstream& file, int const size, int const protocol
+ , address_v4 const source, address_v4 const dest)
+ {
+ ip_header const header = {
+ (4 << 4) | 5, // version_len
+ 0, // dscp
+ htons(std::uint16_t(size)), // length
+ 0, // identification
+ 0, // fragment
+ 200, // ttl
+ std::uint8_t(protocol), // protocol
+ 0, // checksum
+ htonl(std::uint32_t(source.to_uint())), // source ip
+ htonl(std::uint32_t(dest.to_uint())) // destination ip
+ };
+
+ write(file, header);
+ }
+
+ void write_udp_header(std::fstream& file, int const size, int const src_port
+ , int const dst_port)
+ {
+ assert(src_port != 0);
+ assert(dst_port != 0);
+ udp_header const header = {
+ htons(std::uint16_t(src_port)), // source port
+ htons(std::uint16_t(dst_port)), // destination port
+ htons(std::uint16_t(sizeof(udp_header) + size)), // length
+ 0 // checksum
+ };
+
+ write(file, header);
+ }
+
+ void write_tcp_header(std::fstream& file, int const src_port
+ , int const dst_port, std::uint32_t const seq_nr)
+ {
+ assert(src_port != 0);
+ assert(dst_port != 0);
+ tcp_header const header = {
+ htons(std::uint16_t(src_port)), // source port
+ htons(std::uint16_t(dst_port)), // destination port
+ htonl(seq_nr), // sequence number
+ std::uint32_t(0), // acknowledgement number
+ std::uint8_t(5 << 4), // header size (data offset)
+ std::uint8_t(0), // flags
+ htons(std::uint16_t(65535)), // window size
+ std::uint16_t(0), // checksum
+ std::uint16_t(0) // urgent offset
+ };
+
+ write(file, header);
+ }
+
+ void pcap::log_tcp(packet const& p, tcp::endpoint const src
+ , tcp::endpoint const dst)
+ {
+ // synthesize IP/TCP header and write packet
+ auto const now = chrono::high_resolution_clock::now();
+
+ // just an arbitrary posix time used as starting point
+ std::uint32_t const sim_start_time = 441794304;
+ std::uint32_t const secs = static_cast<std::uint32_t>(duration_cast<chrono::seconds>(now.time_since_epoch()).count());
+ std::uint32_t const usecs = static_cast<std::uint32_t>(duration_cast<chrono::microseconds>(now.time_since_epoch() - seconds(secs)).count());
+
+ std::uint32_t const packet_size = static_cast<std::uint32_t>(sizeof(ip_header) + sizeof(tcp_header) + p.buffer.size());
+
+ write(m_file, sim_start_time + secs);
+ write(m_file, usecs);
+ write(m_file, packet_size);
+ write(m_file, packet_size);
+
+ // 6 is the protocol number for TCP
+ write_ip_header(m_file, packet_size, 6
+ , src.address().to_v4(), dst.address().to_v4());
+
+ // TODO: if the packet has error set with asio::error::eof
+ // set the FIN flag
+ write_tcp_header(m_file, p.from.port(), dst.port(), p.byte_counter);
+
+ m_file.write(reinterpret_cast<char const*>(p.buffer.data()), p.buffer.size());
+ }
+
+ void pcap::log_udp(packet const& p, udp::endpoint const src
+ , udp::endpoint const dst)
+ {
+ // synthesize IP/UDP header and write packet
+ auto const now = chrono::high_resolution_clock::now();
+
+ // just an arbitrary posix time used as starting point
+ std::uint32_t const sim_start_time = 441794304;
+ std::uint32_t const secs = static_cast<std::uint32_t>(duration_cast<chrono::seconds>(now.time_since_epoch()).count());
+ std::uint32_t const usecs = static_cast<std::uint32_t>(duration_cast<chrono::microseconds>(now.time_since_epoch() - seconds(secs)).count());
+
+ std::uint32_t const packet_size = static_cast<std::uint32_t>(sizeof(ip_header) + sizeof(udp_header) + p.buffer.size());
+
+ write(m_file, sim_start_time + secs);
+ write(m_file, usecs);
+ write(m_file, packet_size);
+ write(m_file, packet_size);
+
+ // 17 is the protocol number for UDP
+ write_ip_header(m_file, packet_size, 17
+ , src.address().to_v4(), dst.address().to_v4());
+
+ write_udp_header(m_file, static_cast<int>(p.buffer.size()), p.from.port(), static_cast<int>(dst.port()));
+
+ m_file.write(reinterpret_cast<char const*>(p.buffer.data()), p.buffer.size());
+ }
+
+}}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/queue.hpp"
+#include "simulator/handler_allocator.hpp"
+#include <functional>
+#include <cstdio> // for printf
+
+typedef sim::chrono::high_resolution_clock::time_point time_point;
+typedef sim::chrono::high_resolution_clock::duration duration;
+
+namespace sim
+{
+ using namespace aux;
+
+ queue::queue(asio::io_context& ios
+ , int bandwidth
+ , chrono::high_resolution_clock::duration propagation_delay
+ , int max_queue_size
+ , std::string name)
+ : m_max_queue_size(max_queue_size)
+ , m_forwarding_latency(propagation_delay)
+ , m_bandwidth(bandwidth)
+ , m_queue_size(0)
+ , m_node_name(name)
+ , m_forward_timer(ios)
+ , m_last_forward(chrono::high_resolution_clock::now())
+ {}
+
+ std::string queue::label() const
+ {
+ char ret[400];
+ int p = std::snprintf(ret, sizeof(ret), "%s\n", m_node_name.c_str());
+
+ if (m_bandwidth != 0)
+ {
+ p += std::snprintf(ret + p, sizeof(ret) - p, "rate: %d kB/s\n"
+ , m_bandwidth / 1000);
+ }
+
+ if (m_queue_size != 0)
+ {
+ p += std::snprintf(ret + p, sizeof(ret) - p, "queue: %d kB\n"
+ , m_queue_size / 1000);
+ }
+
+ if (m_forwarding_latency.count() != 0)
+ {
+ p += std::snprintf(ret + p, sizeof(ret) - p, "latency: %d ms\n"
+ , int(chrono::duration_cast<chrono::milliseconds>(m_forwarding_latency).count()));
+ }
+
+ return ret;
+ }
+
+ void queue::incoming_packet(aux::packet p)
+ {
+ const int packet_size = int(p.buffer.size() + p.overhead);
+
+ // tail-drop
+ if (p.ok_to_drop()
+ && m_max_queue_size > 0
+ && m_queue_size + packet_size > m_max_queue_size)
+ {
+ // if any hop on the network drops a packet, it has to return it to the
+ // sender.
+ auto drop_fun = std::move(p.drop_fun);
+ if (drop_fun) drop_fun(std::move(p));
+ return;
+ }
+
+ time_point const now = chrono::high_resolution_clock::now();
+
+ m_queue.emplace_back(now + m_forwarding_latency, std::move(p));
+ m_queue_size += packet_size;
+ if (m_queue.size() > 1) return;
+
+ begin_send_next_packet();
+ }
+
+ void queue::begin_send_next_packet()
+ {
+ time_point now = chrono::high_resolution_clock::now();
+
+ if (m_queue.front().ts > now)
+ {
+ m_forward_timer.expires_at(m_queue.front().ts);
+ m_forward_timer.async_wait(make_malloc(std::bind(&queue::begin_send_next_packet
+ , this)));
+ return;
+ }
+
+ m_last_forward = now;
+ if (m_bandwidth == 0)
+ {
+ post(m_forward_timer.get_executor(), make_malloc(std::bind(&queue::next_packet_sent
+ , this)));
+ return;
+ }
+ const double nanoseconds_per_byte = 1000000000.0
+ / double(m_bandwidth);
+
+ aux::packet const& p = m_queue.front().pkt;
+ const int packet_size = int(p.buffer.size() + p.overhead);
+
+ m_last_forward += chrono::duration_cast<duration>(chrono::nanoseconds(
+ boost::int64_t(nanoseconds_per_byte * packet_size)));
+
+ m_forward_timer.expires_at(m_last_forward);
+ m_forward_timer.async_wait(make_malloc(std::bind(&queue::next_packet_sent
+ , this)));
+ }
+
+ void queue::next_packet_sent()
+ {
+ aux::packet p = std::move(m_queue.front().pkt);
+ m_queue.erase(m_queue.begin());
+ const int packet_size = int(p.buffer.size() + p.overhead);
+ m_queue_size -= packet_size;
+
+ forward_packet(std::move(p));
+
+ if (m_queue.size())
+ begin_send_next_packet();
+ }
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include "simulator/handler_allocator.hpp"
+#include <functional>
+
+typedef sim::chrono::high_resolution_clock::time_point time_point;
+typedef sim::chrono::high_resolution_clock::duration duration;
+
+using namespace std::placeholders;
+
+namespace sim {
+namespace asio {
+namespace ip {
+
+ template<typename Protocol>
+ basic_resolver<Protocol>::basic_resolver(io_context& ios)
+ : m_ios(&ios)
+ , m_timer(ios)
+ {}
+
+ template<typename Protocol>
+ basic_resolver<Protocol>::basic_resolver(basic_resolver<Protocol>&&) noexcept = default;
+
+ template<typename Protocol>
+ basic_resolver<Protocol>& basic_resolver<Protocol>::operator=(basic_resolver<Protocol>&&) noexcept = default;
+
+ template<typename Protocol>
+ void basic_resolver<Protocol>::async_resolve(std::string hostname, char const* service
+ , aux::function<void(boost::system::error_code const&, results_type)> handler)
+ {
+ std::vector<asio::ip::address> result;
+ boost::system::error_code ec;
+
+ const chrono::high_resolution_clock::time_point start_time =
+ m_queue.empty() ? chrono::high_resolution_clock::now() :
+ m_queue.front().completion_time;
+
+ assert(!m_ios->get_ips().empty() && "internal io service objects can only "
+ "be used for timers");
+
+ // if the hostname is an IP address, resolve it immediately
+ asio::ip::address addr = make_address_v4(hostname, ec);
+ if (ec) addr = make_address_v6(hostname, ec);
+ if (!ec)
+ {
+ const chrono::high_resolution_clock::time_point t = chrono::high_resolution_clock::now()
+ + chrono::microseconds(1);
+ results_type ips;
+ int const port = atoi(service);
+ assert(port >= 0 && port <= 0xffff);
+ ips.emplace_back(
+ typename Protocol::endpoint(addr, static_cast<unsigned short>(port))
+ , hostname, service);
+ result_t res{t, ec, std::move(ips), std::move(handler) };
+ m_queue.insert(m_queue.begin(), std::move(res));
+ m_timer.expires_at(m_queue.front().completion_time);
+ m_timer.async_wait(aux::make_malloc(std::bind(&basic_resolver::on_lookup, this, _1)));
+ return;
+ }
+ ec.clear();
+
+ const chrono::high_resolution_clock::time_point completion_time =
+ start_time
+ + m_ios->sim().config().hostname_lookup(m_ios->get_ips().front(), hostname
+ , result, ec);
+
+ results_type ips;
+
+ int const port = atoi(service);
+ assert(port >= 0 && port <= 0xffff);
+
+ for (auto const& ip : result)
+ {
+ ips.emplace_back(
+ typename Protocol::endpoint(ip, static_cast<unsigned short>(port))
+ , hostname, service);
+ }
+
+ result_t res{ completion_time, ec, std::move(ips), std::move(handler)};
+ m_queue.emplace_back(std::move(res));
+
+ m_timer.expires_at(m_queue.front().completion_time);
+ m_timer.async_wait(aux::make_malloc(std::bind(&basic_resolver::on_lookup, this, _1)));
+ }
+
+ template<typename Protocol>
+ void basic_resolver<Protocol>::on_lookup(boost::system::error_code const& ec)
+ {
+ if (ec == asio::error::operation_aborted) return;
+
+ if (m_queue.empty()) return;
+
+ typename queue_t::value_type v = std::move(m_queue.front());
+ m_queue.erase(m_queue.begin());
+
+ // once the handler is called, it's possible the last reference keeping
+ // this object (basic_resolver) alive is released and we're deleted. Make
+ // sure to not touch any members after the handler in that case.
+ bool const empty = m_queue.empty();
+ v.handler(v.err, std::move(v.ips));
+ if (empty) return;
+
+ m_timer.expires_at(m_queue.front().completion_time);
+ m_timer.async_wait(aux::make_malloc(std::bind(&basic_resolver::on_lookup, this, _1)));
+ }
+
+ template<typename Protocol>
+ void basic_resolver<Protocol>::cancel()
+ {
+ queue_t q;
+ m_queue.swap(q);
+ for (auto& r : q)
+ {
+ r.err = asio::error::operation_aborted;
+ post(m_timer.get_executor(), aux::make_malloc(std::bind(std::move(r.handler)
+ , r.err, std::move(r.ips))));
+ }
+ }
+
+ // explicitly instantiate the functions
+ template struct basic_resolver<udp>;
+ template struct basic_resolver<tcp>;
+}
+}
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include "simulator/packet.hpp"
+#include "simulator/pcap.hpp"
+
+#include <tuple> // for tie
+#include <memory> // for make_shared
+#include <cstdio> // for printf
+#include <iostream>
+#include <stdexcept> // for std::runtime_error
+
+using namespace sim::asio;
+
+namespace sim
+{
+ simulation::simulation(configuration& config)
+ : m_config(config)
+ , m_internal_ios(new asio::io_context(*this))
+ , m_service(1)
+ {
+ sim::chrono::reset_clock();
+ m_config.build(*this);
+ }
+
+ simulation::~simulation()
+ {
+ m_config.clear();
+
+ assert(m_timer_queue.empty());
+ }
+
+ std::size_t simulation::run() try
+ {
+ std::size_t ret = 0;
+ std::size_t last_executed = 0;
+
+ // Detect a runaway loop where events keep firing but simulated time
+ // never advances - typically a timer being repeatedly scheduled at the
+ // current time (a 100% CPU spin that would otherwise hang run()
+ // forever). Legitimate bursts of same-timestamp events are finite, so
+ // a large threshold reliably distinguishes them from an unbounded spin.
+ chrono::high_resolution_clock::time_point prev_time
+ = chrono::high_resolution_clock::now();
+ std::int64_t stalled_iterations = 0;
+ constexpr std::int64_t max_stalled_iterations = 1000;
+
+ do {
+
+ m_service.restart();
+ last_executed = m_service.poll();
+ ret += last_executed;
+
+ chrono::high_resolution_clock::time_point now
+ = chrono::high_resolution_clock::now();
+
+ std::lock_guard<std::mutex> l(m_timer_queue_mutex);
+ if (!m_timer_queue.empty()) {
+ asio::high_resolution_timer* next_timer = *m_timer_queue.begin();
+ chrono::high_resolution_clock::fast_forward(next_timer->expiry() - now);
+
+ now = chrono::high_resolution_clock::now();
+
+ while (!m_timer_queue.empty()
+ && (*m_timer_queue.begin())->expiry() <= now) {
+
+ next_timer = *m_timer_queue.begin();
+ m_timer_queue.erase(m_timer_queue.begin());
+ next_timer->fire(boost::system::error_code());
+ ++last_executed;
+ ++ret;
+ }
+ }
+
+ if (last_executed > 0) {
+ if (now == prev_time) {
+ if (++stalled_iterations > max_stalled_iterations) {
+ throw std::runtime_error("libsimulator: simulated time "
+ "has not advanced for too many consecutive iterations "
+ "while events keep firing. The simulation is stuck in a "
+ "busy loop, typically a timer repeatedly scheduled at "
+ "the current time (a 100% CPU spin).");
+ }
+ } else {
+ stalled_iterations = 0;
+ prev_time = now;
+ }
+ }
+
+// std::fprintf(stderr, "run: last_executed: %d stopped: %d timer-queue: %d\n"
+// , int(last_executed), m_stopped, int(m_timer_queue.size()));
+ } while (last_executed > 0 && !m_stopped);
+
+// std::fprintf(stderr, "exiting simulation::run(): last_executed: %d stopped: %d timer-queue: %d ret: %d\n"
+// , int(last_executed), m_stopped, int(m_timer_queue.size()), int(ret));
+ return ret;
+ }
+ catch (...)
+ {
+ // cancel all outstanding timers
+ // we make a copy, since cancelling the timers will mutate m_timer_queue
+ auto queue = m_timer_queue;
+ for (auto& t : queue)
+ t->cancel();
+
+ auto listen_sockets = m_listen_sockets;
+ for (auto& s : listen_sockets)
+ s.second->cancel();
+
+ auto udp_sockets = m_udp_sockets;
+ for (auto& s : udp_sockets)
+ s.second->cancel();
+ m_stopped = true;
+ throw;
+ }
+
+ void simulation::stop() { m_stopped = true; }
+ bool simulation::stopped() const { return m_stopped; }
+ void simulation::restart() { m_stopped = false; }
+
+ void simulation::add_timer(asio::high_resolution_timer* t)
+ {
+ assert(!m_stopped);
+ if (t->expiry() == sim::chrono::high_resolution_clock::now())
+ {
+ std::fprintf(stderr, "WARNING: timer scheduled for current time!\n");
+ }
+ std::lock_guard<std::mutex> l(m_timer_queue_mutex);
+ // make sure we get a deterministic ordering of timers with the same
+ // expiration time
+ auto it = std::upper_bound(m_timer_queue.begin(), m_timer_queue.end(), t, timer_compare());
+ m_timer_queue.insert(it, t);
+ }
+
+ void simulation::remove_timer(asio::high_resolution_timer* t)
+ {
+ std::lock_guard<std::mutex> l(m_timer_queue_mutex);
+ if (m_timer_queue.empty()) return;
+ timer_queue_t::iterator begin;
+ timer_queue_t::iterator end;
+ std::tie(begin, end) = std::equal_range(m_timer_queue.begin(), m_timer_queue.end(), t, timer_compare());
+ if (begin == end) return;
+ begin = std::find(begin, end, t);
+ if (begin == end) return;
+ m_timer_queue.erase(begin);
+ }
+
+ void simulation::rebind_socket(ip::tcp::socket* prev, ip::tcp::socket* s, ip::tcp::endpoint ep)
+ {
+ auto i = m_listen_sockets.find(ep);
+ assert(i != m_listen_sockets.end());
+ if (i->second != prev) return;
+ i->second = s;
+ }
+
+ ip::tcp::endpoint simulation::bind_socket(ip::tcp::socket* socket
+ , ip::tcp::endpoint ep, boost::system::error_code& ec)
+ {
+ assert(ep.address() != boost::asio::ip::address());
+
+ if (ep.port() < 1024 && ep.port() > 0)
+ {
+ // emulate process not running as root
+ ec = boost::asio::error::access_denied;
+ return ip::tcp::endpoint();
+ }
+
+ if (ep.port() == 0)
+ {
+ // if the socket is being bound to port 0, it means the system picks a
+ // free port. We want to avoid re-using ports, because that may confuse
+ // wireshark when threading together the TCP streams.
+ ep.port(m_next_bind_port++);
+ if (m_next_bind_port > 65534) m_next_bind_port = 2000;
+
+ listen_socket_iter_t i = m_listen_sockets.lower_bound(ep);
+ while (i != m_listen_sockets.end() && i->first == ep)
+ {
+ ep.port(ep.port() + 1);
+ if (ep.port() > 65530)
+ {
+ ec = boost::asio::error::address_in_use;
+ return ip::tcp::endpoint();
+ }
+ i = m_listen_sockets.lower_bound(ep);
+ }
+ }
+
+ listen_socket_iter_t i = m_listen_sockets.lower_bound(ep);
+ if (i != m_listen_sockets.end() && i->first == ep)
+ {
+ ec = boost::asio::error::address_in_use;
+ return ip::tcp::endpoint();
+ }
+
+ m_listen_sockets.insert(i, std::make_pair(ep, socket));
+ ec.clear();
+ return ep;
+ }
+
+ void simulation::unbind_socket(ip::tcp::socket* socket
+ , const ip::tcp::endpoint& ep)
+ {
+ listen_socket_iter_t i = m_listen_sockets.find(ep);
+ if (i == m_listen_sockets.end() || i->second != socket) return;
+ m_listen_sockets.erase(i);
+ }
+
+ void simulation::rebind_udp_socket(ip::udp::socket* socket, ip::udp::endpoint ep)
+ {
+ auto i = m_udp_sockets.find(ep);
+ assert(i != m_udp_sockets.end());
+ i->second = socket;
+ }
+
+ ip::udp::endpoint simulation::bind_udp_socket(ip::udp::socket* socket
+ , ip::udp::endpoint ep, boost::system::error_code& ec)
+ {
+ assert(ep.address() != boost::asio::ip::address());
+
+ if (ep.port() < 1024 && ep.port() > 0)
+ {
+ // emulate process not running as root
+ ec = boost::asio::error::access_denied;
+ return ip::udp::endpoint();
+ }
+
+ if (ep.port() == 0)
+ {
+ // if the socket is being bound to port 0, it means the system picks a
+ // free port.
+
+ ep.port(m_next_bind_port++);
+ if (m_next_bind_port > 65534) m_next_bind_port = 2000;
+ udp_socket_iter_t i = m_udp_sockets.lower_bound(ep);
+ while (i != m_udp_sockets.end() && i->first == ep)
+ {
+ ep.port(ep.port() + 1);
+ if (ep.port() > 65530)
+ {
+ ec = boost::asio::error::address_in_use;
+ return ip::udp::endpoint();
+ }
+ i = m_udp_sockets.lower_bound(ep);
+ }
+ }
+
+ udp_socket_iter_t i = m_udp_sockets.lower_bound(ep);
+ if (i != m_udp_sockets.end() && i->first == ep)
+ {
+ ec = boost::asio::error::address_in_use;
+ return ip::udp::endpoint();
+ }
+
+ m_udp_sockets.insert(i, std::make_pair(ep, socket));
+ ec.clear();
+ return ep;
+ }
+
+ void simulation::unbind_udp_socket(ip::udp::socket* socket
+ , const ip::udp::endpoint& ep)
+ {
+ udp_socket_iter_t i = m_udp_sockets.find(ep);
+ if (i == m_udp_sockets.end() || i->second != socket) return;
+ m_udp_sockets.erase(i);
+ }
+
+ std::shared_ptr<aux::channel> simulation::internal_connect(
+ asio::ip::tcp::socket* s
+ , ip::tcp::endpoint const& target, boost::system::error_code& ec)
+ {
+ // find remote socket
+ listen_sockets_t::iterator i = m_listen_sockets.find(target);
+ if (i == m_listen_sockets.end())
+ {
+ ec = boost::system::error_code(error::connection_refused);
+ return std::shared_ptr<aux::channel>();
+ }
+
+ // make sure it's a listening socket
+ ip::tcp::socket* remote = i->second;
+ if (!remote->internal_is_listening())
+ {
+ ec = boost::system::error_code(error::connection_refused);
+ return std::shared_ptr<aux::channel>();
+ }
+
+ // create a channel
+ std::shared_ptr<aux::channel> c = std::make_shared<aux::channel>();
+
+ asio::ip::tcp::endpoint from = s->local_bound_to(ec);
+
+ route network_route = m_config.channel_route(from.address()
+ , target.address());
+ c->hops[0] = remote->get_outgoing_route() + network_route + s->get_incoming_route();
+ c->hops[1] = s->get_outgoing_route() + network_route + remote->get_incoming_route();
+
+ c->ep[0] = s->local_bound_to(ec);
+ c->ep[1] = remote->local_bound_to(ec);
+
+ c->visible_ep[0] = s->local_bound_to(ec);
+ c->visible_ep[1] = remote->local_bound_to(ec);
+
+ aux::packet p;
+ p.type = aux::packet::type_t::syn;
+ p.overhead = 28;
+ p.from = asio::ip::udp::endpoint(from.address(), from.port());
+ p.channel = c;
+ if (ec) return std::shared_ptr<aux::channel>();
+
+ p.hops = c->hops[1];
+
+ forward_packet(std::move(p));
+
+ return c;
+ }
+
+ route simulation::find_udp_socket(asio::ip::udp::socket const& socket
+ , ip::udp::endpoint const& ep)
+ {
+ udp_socket_iter_t i = m_udp_sockets.find(ep);
+ if (i == m_udp_sockets.end())
+ return route();
+
+ ip::udp::endpoint src = socket.local_bound_to();
+ route network_route = m_config.channel_route(src.address(), ep.address());
+
+ // ask the socket for its incoming route
+ network_route.append(i->second->get_incoming_route());
+
+ return network_route;
+ }
+
+ void simulation::add_io_service(asio::io_context* ios)
+ {
+ bool added = m_nodes.insert(ios).second;
+ (void)added;
+ assert(added);
+ }
+
+ void simulation::remove_io_service(asio::io_context* ios)
+ {
+ auto it = m_nodes.find(ios);
+ assert(it != m_nodes.end());
+ m_nodes.erase(it);
+ }
+
+ std::vector<io_context*> simulation::get_all_io_services() const
+ {
+ std::vector<io_context*> ret;
+ ret.reserve(m_nodes.size());
+ std::remove_copy_if(
+ m_nodes.begin(), m_nodes.end(), std::back_inserter(ret)
+ , [](io_context* ios) { return ios->get_ips().empty(); });
+ return ret;
+ }
+
+ void simulation::log_pcap(char const* filename)
+ {
+ std::printf("saving packet capture to: \"%s\"\n", filename);
+ m_pcap = std::unique_ptr<aux::pcap>(new aux::pcap(filename));
+ }
+
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include "simulator/packet.hpp"
+
+#include <functional>
+#include <unordered_set>
+#include <set>
+#include <cstdio> // for printf
+
+#include "simulator/push_warnings.hpp"
+#include <boost/system/error_code.hpp>
+#include "simulator/pop_warnings.hpp"
+
+typedef sim::chrono::high_resolution_clock::time_point time_point;
+typedef sim::chrono::high_resolution_clock::duration duration;
+
+namespace sim {
+namespace asio {
+namespace ip {
+
+ default_config default_cfg;
+
+} // ip
+} // asio
+
+void forward_packet(aux::packet p)
+{
+ std::shared_ptr<sink> next_hop = p.hops.pop_front();
+ if (!next_hop)
+ {
+ std::fprintf(stderr, "packet lost\n");
+ return;
+ }
+ next_hop->incoming_packet(std::move(p));
+}
+
+namespace
+{
+ // this is a dummy sink for endpoints, wrapping an io_context
+ struct endpoint : sink
+ {
+ endpoint(asio::io_context& ioc)
+ : m_ioc(ioc)
+ {}
+
+ virtual void incoming_packet(aux::packet /* p */) override final { assert(false); }
+
+ virtual std::string label() const override final
+ {
+ std::string ret;
+ for (auto const& ip : m_ioc.get_ips())
+ {
+ ret += ip.to_string();
+ ret += " ";
+ }
+ return ret;
+ }
+
+ virtual std::string attributes() const override final
+ {
+ return "shape=ellipse";
+ }
+
+ private:
+ asio::io_context& m_ioc;
+ };
+}
+
+namespace
+{
+ std::string escape_label(std::string n)
+ {
+ std::string ret;
+ for (auto c : n)
+ {
+ if (c == '\n')
+ {
+ ret += "\\n";
+ continue;
+ }
+ if (c == '\"')
+ {
+ ret += "\\\"";
+ continue;
+ }
+ ret += c;
+ }
+ return ret;
+ }
+}
+
+void dump_network_graph(simulation const& s, const std::string& filename)
+{
+ // all edges (directed).
+ std::set<std::pair<std::shared_ptr<sink>, std::shared_ptr<sink>>> edges;
+
+ // all network nodes
+ std::unordered_set<std::shared_ptr<sink>> nodes;
+
+ // local nodes (subgrapgs)
+ std::vector<std::unordered_set<std::shared_ptr<sink>>> local_nodes;
+
+ const std::vector<asio::io_context*> io_services = s.get_all_io_services();
+
+ for (auto ioc : io_services)
+ {
+ std::shared_ptr<sink> ep = std::make_shared<endpoint>(*ioc);
+ local_nodes.push_back(std::unordered_set<std::shared_ptr<sink>>());
+ local_nodes.back().insert(ep);
+
+ for (auto const& ip : ioc->get_ips())
+ {
+ route in = ioc->get_incoming_route(ip);
+ route out = ioc->get_outgoing_route(ip);
+
+ // this is the outgoing node for this endpoint. This is
+ // how it connects to the network.
+ const std::shared_ptr<sink> egress = out.empty() ? ep : out.last();
+
+ // first add both the incoming and outgoing chains
+ std::shared_ptr<sink> prev;
+ while (!in.empty())
+ {
+ auto node = in.pop_front();
+ local_nodes.back().insert(node);
+ if (prev) edges.insert({prev, node});
+ prev = node;
+ }
+ if (prev) edges.insert({prev, ep});
+
+ prev = ep;
+ while (!out.empty())
+ {
+ auto node = out.pop_front();
+ local_nodes.back().insert(node);
+ edges.insert({prev, node});
+ prev = node;
+ }
+
+ // then connect the endpoint of those chains to the rest of the network.
+ // Since the network may be arbitrarily complex, we actually have to
+ // completely iterate over all other endpoints
+
+ for (auto ios2 : io_services)
+ {
+ for (auto const& ip2 : ios2->get_ips())
+ {
+ route network = s.config().channel_route(
+ ip, ip2);
+
+ std::shared_ptr<sink> last = ios2->get_incoming_route(ip2).next_hop();
+
+ prev = egress;
+ while (!network.empty())
+ {
+ auto node = network.pop_front();
+ nodes.insert(node);
+ edges.insert({prev, node});
+ prev = node;
+ }
+ edges.insert({prev, last});
+ }
+ }
+ }
+ }
+
+ // by now, the nodes and edges should represent the complete graph. Render it
+ // into dot.
+
+ FILE* f = fopen(filename.c_str(), "w+");
+
+ std::fprintf(f, "digraph network {\n"
+ "concentrate=true;\n"
+ "overlap=scale;\n"
+ "splines=true;\n");
+
+ std::fprintf(f, "\n// nodes\n\n");
+
+ for (const auto& n : nodes)
+ {
+ std::string attributes = n->attributes();
+ std::fprintf(f, " \"%p\" [label=\"%s\",style=\"filled\",color=\"red\"%s%s];\n"
+ , static_cast<void*>(n.get())
+ , escape_label(n->label()).c_str()
+ , attributes.empty() ? "" : ", "
+ , attributes.c_str());
+ }
+
+ std::fprintf(f, "\n// local networks\n\n");
+
+ int idx = 0;
+ for (auto ln : local_nodes)
+ {
+ std::fprintf(f, "subgraph cluster_%d {\n", idx++);
+
+ for (const auto& n : ln)
+ {
+ std::string attributes = n->attributes();
+ std::fprintf(f, " \"%p\" [label=\"%s\",style=\"filled\",color=\"green\"%s%s];\n"
+ , static_cast<void*>(n.get())
+ , escape_label(n->label()).c_str()
+ , attributes.empty() ? "" : ", "
+ , attributes.c_str());
+ }
+
+ std::fprintf(f, "}\n");
+ }
+
+ std::fprintf(f, "\n// edges\n\n");
+
+ while (!edges.empty())
+ {
+ auto edge = *edges.begin();
+ edges.erase(edges.begin());
+
+ std::fprintf(f, "\"%p\" -> \"%p\"\n"
+ , static_cast<void*>(edge.first.get())
+ , static_cast<void*>(edge.second.get()));
+ }
+
+ std::fprintf(f, "}\n");
+ fclose(f);
+}
+
+namespace aux {
+
+ int channel::remote_idx(const asio::ip::tcp::endpoint& self) const
+ {
+ if (ep[0] == self) return 1;
+ if (ep[1] == self) return 0;
+ assert(false && "invalid socket");
+ return -1;
+ }
+
+ int channel::self_idx(const asio::ip::tcp::endpoint& self) const
+ {
+ if (ep[0] == self) return 0;
+ if (ep[1] == self) return 1;
+ assert(false && "invalid socket");
+ return -1;
+ }
+
+} // aux
+} // sim
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/sink_forwarder.hpp"
+#include "simulator/packet.hpp"
+
+namespace sim { namespace aux {
+
+ sink_forwarder::sink_forwarder(sink* dst)
+ : m_dst(dst)
+ {}
+
+ void sink_forwarder::incoming_packet(packet p)
+ {
+ if (m_dst == nullptr) return;
+ m_dst->incoming_packet(std::move(p));
+ }
+
+ std::string sink_forwarder::label() const
+ {
+ return m_dst ? m_dst->label() : "";
+ }
+
+ void sink_forwarder::reset(sink* s)
+ {
+ m_dst = s;
+ }
+
+}}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include "simulator/socks_server.hpp"
+
+#include <functional>
+#include <cstdint>
+#include <cinttypes>
+#include <cstdio> // for printf
+
+using namespace sim::asio;
+using namespace sim::asio::ip;
+
+using boost::system::error_code;
+
+namespace sim
+{
+ using namespace aux;
+
+ socks_server::socks_server(io_context& ios, unsigned short listen_port, int version
+ , std::uint32_t const flags)
+ : m_ios(ios)
+ , m_listen_socket(ios)
+ , m_conn(std::make_shared<socks_connection>(m_ios, version, m_cmd_counts, flags, m_bind_port))
+ , m_version(version)
+ , m_flags(flags)
+ {
+ m_cmd_counts.fill(0);
+ address local_ip = ios.get_ips().front();
+ if (local_ip.is_v4())
+ {
+ m_listen_socket.open(tcp::v4());
+ m_listen_socket.bind(tcp::endpoint(address_v4::any(), listen_port));
+ }
+ else
+ {
+ m_listen_socket.open(tcp::v6());
+ m_listen_socket.bind(tcp::endpoint(address_v6::any(), listen_port));
+ }
+ m_listen_socket.listen();
+
+ m_listen_socket.async_accept(m_conn->socket(), m_ep
+ , std::bind(&socks_server::on_accept, this, std::placeholders::_1));
+ }
+
+ void socks_server::on_accept(error_code const& ec)
+ {
+ if (ec == asio::error::operation_aborted)
+ return;
+
+ if (ec)
+ {
+ std::printf("socks_server::on_accept: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ return;
+ }
+
+ std::printf("socks_server accepted connection from: %s : %d\n",
+ m_ep.address().to_string().c_str(), m_ep.port());
+
+ m_conn->start();
+
+ // create a new connection to accept into
+ m_conn = std::make_shared<socks_connection>(m_ios, m_version, m_cmd_counts, m_flags, m_bind_port);
+
+ // now we can accept another connection
+ m_listen_socket.async_accept(m_conn->socket(), m_ep
+ , std::bind(&socks_server::on_accept, this, std::placeholders::_1));
+ }
+
+ void socks_server::stop()
+ {
+ m_close = true;
+ m_listen_socket.close();
+ }
+
+ socks_connection::socks_connection(asio::io_context& ios
+ , int version, std::array<int, 3>& cmd_counts, std::uint32_t const flags, int& bind_port)
+ : m_bind_port(bind_port)
+ , m_ios(ios)
+ , m_udp_resolver(ios)
+ , m_resolver(m_ios)
+ , m_client_connection(ios)
+ , m_server_connection(m_ios)
+ , m_bind_socket(m_ios)
+ , m_udp_associate(m_ios)
+ , m_num_out_bytes(0)
+ , m_num_in_bytes(0)
+ , m_version(version)
+ , m_command(0)
+ , m_cmd_counts(cmd_counts)
+ , m_flags(flags)
+ {
+ }
+
+ void socks_connection::start()
+ {
+ if (m_version == 4)
+ {
+ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0], 9)
+ , std::bind(&socks_connection::on_request1, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+ } else {
+ // read protocol version and number of auth-methods
+ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0], 2)
+ , std::bind(&socks_connection::on_handshake1, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+ }
+ }
+
+ void socks_connection::on_handshake1(error_code const& ec, size_t bytes_transferred)
+ {
+ if (ec || bytes_transferred != 2)
+ {
+ std::printf("socks_connection::on_handshake1: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ if (m_out_buffer[0] != 4 && m_out_buffer[0] != 5)
+ {
+ std::printf("socks_connection::on_handshake1: unexpected socks protocol version: %d"
+ , int(m_out_buffer[0]));
+ close_connection();
+ return;
+ }
+
+ int num_methods = unsigned(m_out_buffer[1]);
+
+ // read list of auth-methods
+ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0],
+ num_methods)
+ , std::bind(&socks_connection::on_handshake2, shared_from_this()
+ , std::placeholders::_1, std::placeholders::_2));
+ }
+
+ void socks_connection::on_handshake2(error_code const& ec, size_t bytes_transferred)
+ {
+ if (ec)
+ {
+ std::printf("socks_connection::on_handshake2: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ if (std::count(m_out_buffer, m_out_buffer + bytes_transferred, 0) == 0)
+ {
+ std::printf("socks_connection: could not find auth-method 0 (no-auth) in socks handshake\n");
+ close_connection();
+ return;
+ }
+
+ m_in_buffer[0] = 5; // socks version
+ m_in_buffer[1] = 0; // auth-method (no-auth)
+
+ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], 2)
+ , std::bind(&socks_connection::on_handshake3, shared_from_this()
+ , std::placeholders::_1, std::placeholders::_2));
+ }
+
+ void socks_connection::on_handshake3(error_code const& ec, size_t bytes_transferred)
+ {
+ if (ec || bytes_transferred != 2)
+ {
+ std::printf("socks_connection::on_handshake3: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0], 10)
+ , std::bind(&socks_connection::on_request1, shared_from_this()
+ , std::placeholders::_1, std::placeholders::_2));
+ }
+
+ void socks_connection::on_request1(error_code const& ec, size_t bytes_transferred)
+ {
+ size_t const expected = m_version == 4 ? 9 : 10;
+ if (ec || bytes_transferred != expected)
+ {
+ std::printf("socks_connection::on_request1: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+// +----+-----+-------+------+----------+----------+
+// |VER | CMD | RSV | ATYP | DST.ADDR | DST.PORT |
+// +----+-----+-------+------+----------+----------+
+// | 1 | 1 | X'00' | 1 | Variable | 2 |
+// +----+-----+-------+------+----------+----------+
+
+ int const version = m_out_buffer[0];
+ int const command = m_out_buffer[1];
+ m_command = command;
+ ++m_cmd_counts[command - 1];
+
+ if (version != m_version)
+ {
+ std::printf("socks_connection::on_request1: unexpected socks protocol version: %d expected: %d\n"
+ , int(m_out_buffer[0]), m_version);
+ close_connection();
+ return;
+ }
+
+ if (m_version == 4)
+ {
+ if (command != 1 && command != 2)
+ {
+ std::printf("socks_connection::on_request1: unexpected socks command: %d\n"
+ , command);
+ close_connection();
+ return;
+ }
+
+ std::uint16_t port = m_out_buffer[2] & 0xff;
+ port <<= 8;
+ port |= m_out_buffer[3] & 0xff;
+
+ std::uint32_t addr = m_out_buffer[4] & 0xff;
+ addr <<= 8;
+ addr |= m_out_buffer[5] & 0xff;
+ addr <<= 8;
+ addr |= m_out_buffer[6] & 0xff;
+ addr <<= 8;
+ addr |= m_out_buffer[7] & 0xff;
+
+ if (m_out_buffer[8] != 0)
+ {
+ // in this case, we would have to read one byte at a time until we
+ // get to the null terminator.
+ std::printf("socks_connection::on_request1: username in SOCKS4 mode not supported\n");
+ close_connection();
+ return;
+ }
+ asio::ip::tcp::endpoint target(asio::ip::address_v4(addr), port);
+ if (command == 1)
+ {
+ open_forward_connection(target);
+ }
+ else if (command == 2)
+ {
+ bind_connection(target);
+ }
+
+ return;
+ }
+
+ if (command != 1 && command != 2 && command != 3)
+ {
+ std::printf("socks_connection::on_request1: unexpected command: %d\n"
+ , command);
+ close_connection();
+ return;
+ }
+
+ if (m_out_buffer[2] != 0)
+ {
+ std::printf("socks_connection::on_request1: reserved byte is non-zero: %d\n"
+ , int(m_out_buffer[2]));
+ close_connection();
+ return;
+ }
+
+ int atyp = unsigned(m_out_buffer[3]);
+
+ if (atyp != 1 && atyp != 3 && atyp != 4)
+ {
+ std::printf("socks_connection::on_request1: unexpected address type in SOCKS request: %d\n"
+ , atyp);
+ close_connection();
+ return;
+ }
+
+ std::printf("socks_connection: received %s request address type: %d\n"
+ , command == 1 ? "CONNECT"
+ : command == 2 ? "BIND"
+ : "UDP_ASSOCIATE", atyp);
+
+ switch (atyp)
+ {
+ case 1: { // IPv4 address (we have the whole request already)
+
+// +----+-----+-------+------+----------+----------+
+// |VER | CMD | RSV | ATYP | BND.ADDR | BND.PORT |
+// +----+-----+-------+------+----------+----------+
+// | 1 | 1 | X'00' | 1 | 4 | 2 |
+// +----+-----+-------+------+----------+----------+
+
+ std::uint32_t addr = m_out_buffer[4] & 0xff;
+ addr <<= 8;
+ addr |= m_out_buffer[5] & 0xff;
+ addr <<= 8;
+ addr |= m_out_buffer[6] & 0xff;
+ addr <<= 8;
+ addr |= m_out_buffer[7] & 0xff;
+
+ std::uint16_t port = m_out_buffer[8] & 0xff;
+ port <<= 8;
+ port |= m_out_buffer[9] & 0xff;
+
+ asio::ip::tcp::endpoint target(asio::ip::address_v4(addr), port);
+ if (command == 1)
+ {
+ open_forward_connection(target);
+ }
+ else if (command == 2)
+ {
+ bind_connection(target);
+ }
+ else if (command == 3)
+ {
+ if (target.address() == address())
+ {
+ target.address(m_client_connection.remote_endpoint().address());
+ }
+ udp_associate(target);
+ }
+
+ break;
+ }
+ case 3: { // domain name
+
+// +----+-----+-------+------+-----+----------+----------+
+// |VER | CMD | RSV | ATYP | LEN | BND.ADDR | BND.PORT |
+// +----+-----+-------+------+-----+----------+----------+
+// | 1 | 1 | X'00' | 1 | 1 | Variable | 2 |
+// +----+-----+-------+------+-----+----------+----------+
+
+ if (command == 2)
+ {
+ std::printf("ERROR: cannot BIND to hostname address (only IPv4 or IPv6 addresses)\n");
+ close_connection();
+ return;
+ }
+
+ const int len = std::uint8_t(m_out_buffer[4]);
+ // we already read an address of length 4, assuming it was an IPv4
+ // address. Now, with a domain name, one of those bytes was the
+ // length-prefix, but we still read 3 bytes already.
+ const int additional_bytes = len - 3;
+ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[10], additional_bytes)
+ , std::bind(&socks_connection::on_request_domain_name
+ , shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+ break;
+ }
+ case 4: // IPv6 address
+
+// +----+-----+-------+------+----------+----------+
+// |VER | CMD | RSV | ATYP | BND.ADDR | BND.PORT |
+// +----+-----+-------+------+----------+----------+
+// | 1 | 1 | X'00' | 1 | 16 | 2 |
+// +----+-----+-------+------+----------+----------+
+
+ std::printf("ERROR: unsupported address type %d\n", atyp);
+ close_connection();
+ }
+ }
+
+ void socks_connection::on_request_domain_name(error_code const& ec, size_t bytes_transferred)
+ {
+ if (ec)
+ {
+ std::printf("socks_connection::on_request_domain_name(%s): (%d) %s\n"
+ , command(), ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ int const buffer_size = int(10 + bytes_transferred);
+
+ std::uint16_t port = m_out_buffer[buffer_size - 2] & 0xff;
+ port <<= 8;
+ port |= m_out_buffer[buffer_size - 1] & 0xff;
+
+ std::string hostname(&m_out_buffer[5], std::uint8_t(m_out_buffer[4]));
+ std::printf("socks_connection::on_request_domain_name(%s): hostname: %s port: %d\n"
+ , command(), hostname.c_str(), port);
+
+ char port_str[10];
+ std::snprintf(port_str, sizeof(port_str), "%d", port);
+ m_resolver.async_resolve(hostname, port_str
+ , std::bind(&socks_connection::on_request_domain_lookup
+ , shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+ }
+
+ void socks_connection::on_request_domain_lookup(boost::system::error_code const& ec
+ , asio::ip::tcp::resolver::results_type const ips)
+ {
+ if (ec || ips.empty())
+ {
+ if (ec)
+ {
+ std::printf("socks_connection::on_request_domain_lookup(%s): (%d) %s\n"
+ , command(), ec.value(), ec.message().c_str());
+ }
+ else
+ {
+ std::printf("socks_connection::on_request_domain_lookup(%s): empty response\n"
+ , command());
+ }
+
+// +----+-----+-------+------+----------+----------+
+// |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
+// +----+-----+-------+------+----------+----------+
+// | 1 | 1 | X'00' | 1 | Variable | 2 |
+// +----+-----+-------+------+----------+----------+
+
+ m_in_buffer[0] = char(m_version); // version
+ m_in_buffer[1] = 4; // response (host unreachable)
+ m_in_buffer[2] = 0; // reserved
+ m_in_buffer[3] = 1; // IPv4
+ memset(&m_in_buffer[4], 0, 4);
+ m_in_buffer[8] = 0; // port
+ m_in_buffer[9] = 0;
+
+ auto self = shared_from_this();
+ asio::async_write(m_client_connection
+ , asio::buffer(&m_in_buffer[0], 10)
+ , [=](boost::system::error_code const&, size_t)
+ {
+ self->close_connection();
+ });
+ return;
+ }
+
+ std::printf("socks_connection::on_request_domain_lookup(%s): connecting to: %s port: %d\n"
+ , command()
+ , ips.front().endpoint().address().to_string().c_str()
+ , ips.front().endpoint().port());
+ open_forward_connection(ips.front().endpoint());
+ }
+
+ void socks_connection::open_forward_connection(const asio::ip::tcp::endpoint& target)
+ {
+ std::printf("socks_connection::open_forward_connection(%s): connecting to %s port %d\n"
+ , command(), target.address().to_string().c_str(), target.port());
+
+ m_server_connection.open(target.protocol());
+ m_server_connection.async_connect(target
+ , std::bind(&socks_connection::on_connected, shared_from_this()
+ , std::placeholders::_1));
+ }
+
+ void socks_connection::bind_connection(const asio::ip::tcp::endpoint& target)
+ {
+ std::printf("socks_connection::bind_connection(%s): binding to %s port %d\n"
+ , command(), target.address().to_string().c_str(), target.port());
+
+ error_code ec;
+ m_bind_socket.open(target.protocol(), ec);
+ if (ec)
+ {
+ std::printf("ERROR: open bind socket failed: (%d) %s\n", ec.value()
+ , ec.message().c_str());
+ }
+ else
+ {
+ m_bind_socket.bind(target, ec);
+ }
+
+ int const response = ec
+ ? (m_version == 4 ? 91 : 1)
+ : (m_version == 4 ? 90 : 0);
+ tcp::endpoint ep = m_bind_socket.local_endpoint();
+ int const len = format_response(ep.address(), ep.port(), response);
+
+ if (ec)
+ {
+ std::printf("ERROR: binding socket to %s %d failed: (%d) %s\n"
+ , target.address().to_string().c_str()
+ , target.port()
+ , ec.value()
+ , ec.message().c_str());
+
+ auto self = shared_from_this();
+
+ asio::async_write(m_client_connection
+ , asio::buffer(&m_in_buffer[0], len)
+ , [=](boost::system::error_code const&, size_t)
+ {
+ self->close_connection();
+ });
+ return;
+ }
+
+ // send response
+ asio::async_write(m_client_connection
+ , asio::buffer(&m_in_buffer[0], len)
+ , std::bind(&socks_connection::start_accept, shared_from_this(), std::placeholders::_1));
+ }
+
+ void socks_connection::udp_associate(const asio::ip::tcp::endpoint& target)
+ {
+ std::printf("socks_connection::udp_associate(%s): %s:%d\n"
+ , command(), target.address().to_string().c_str(), target.port());
+
+ m_udp_associate_ep.address(target.address());
+ m_udp_associate_ep.port(target.port());
+
+ error_code ec;
+ m_udp_associate.open(m_udp_associate_ep.protocol(), ec);
+ if (ec)
+ {
+ std::printf("ERROR: open UDP associate socket failed: (%d) %s\n", ec.value()
+ , ec.message().c_str());
+ }
+ else
+ {
+ m_udp_associate.bind(udp::endpoint(address_v4(), std::uint16_t(m_bind_port++)), ec);
+ if (ec)
+ {
+ std::printf("ERROR: binding socket failed: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ }
+ else
+ {
+ m_udp_associate.non_blocking(true);
+ m_udp_associate.async_receive_from(boost::asio::buffer(m_udp_buffer)
+ , m_udp_from, 0, std::bind(&socks_connection::on_read_udp, this, std::placeholders::_1, std::placeholders::_2));
+ }
+ }
+
+ int const response = ec ? 1 : 0;
+ udp::endpoint ep = m_udp_associate.local_bound_to();
+ int const len = (m_flags & udp_associate_respond_empty_hostname)
+ ? format_hostname_response("foobar", ep.port(), response)
+ : format_response(ep.address(), ep.port(), response);
+
+ if (ec)
+ {
+ auto self = shared_from_this();
+
+ asio::async_write(m_client_connection
+ , asio::buffer(&m_in_buffer[0], len)
+ , [=](boost::system::error_code const&, size_t)
+ {
+ self->close_connection();
+ });
+ return;
+ }
+
+ // send response
+ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], len)
+ , std::bind(&socks_connection::wait_for_eof, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+ }
+
+ void socks_connection::wait_for_eof(boost::system::error_code const& ec, std::size_t)
+ {
+ if (ec)
+ {
+ std::printf("socks_connection::wait_for_eof: %s\n", ec.message().c_str());
+ m_udp_associate.close();
+ m_udp_associate_ep = udp::endpoint();
+ m_client_connection.close();
+ return;
+ }
+
+ if (m_flags & socks_flag::disconnect_udp_associate)
+ {
+ std::printf("socks_connection::wait_for_eof: closing connection prematurely\n");
+ m_client_connection.close();
+ return;
+ }
+
+ m_client_connection.async_read_some(
+ asio::buffer(m_out_buffer)
+ , std::bind(&socks_connection::wait_for_eof, shared_from_this()
+ , std::placeholders::_1, std::placeholders::_2));
+ }
+
+ void socks_connection::on_read_udp(boost::system::error_code const& ec
+ , std::size_t bytes_transferred)
+ {
+ std::printf("socks_connection::on_read_udp\n");
+ if (ec)
+ {
+ std::printf("socks_connection::on_read_udp: %s\n", ec.message().c_str());
+ return;
+ }
+
+ // if the client didn't specify an IP and port it would send packets from,
+ // we assumed the same IP as the TCP connection and assume the port is the
+ // same as the first UDP packet from that host
+ if (m_udp_associate_ep.port() == 0
+ && m_udp_from.address() == m_udp_associate_ep.address())
+ {
+ m_udp_associate_ep.port(m_udp_from.port());
+ }
+
+ if (m_udp_from == m_udp_associate_ep)
+ {
+ // read UDP ASSICOATE header and forward outgoing packet
+ // +----+------+------+----------+----------+----------+
+ // |RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA |
+ // +----+------+------+----------+----------+----------+
+ // | 2 | 1 | 1 | Variable | 2 | Variable |
+ // +----+------+------+----------+----------+----------+
+
+ char const* buf = m_udp_buffer.data();
+ if (buf[2] != 0) std::printf("fragment != 0, not supported\n");
+
+ int const atyp = buf[3];
+ if (atyp == 3)
+ {
+ // hostname
+ int const len = buf[4];
+
+ buf += 5;
+ bytes_transferred -= 5;
+ std::string const hostname(buf, len);
+ buf += len;
+ bytes_transferred -= len;
+
+ std::uint16_t port = buf[0] & 0xff;
+ port <<= 8;
+ port |= buf[1] & 0xff;
+ buf += 2;
+ bytes_transferred -= 2;
+
+ auto it = m_name_mapping.right.find(hostname);
+ if (it != m_name_mapping.right.end())
+ {
+ error_code err;
+ m_udp_associate.send_to(boost::asio::buffer(buf, bytes_transferred)
+ , udp::endpoint(it->second, port), 0, err);
+ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
+ return;
+ }
+
+ std::vector<char> forward_buffer(buf, buf + bytes_transferred);
+
+ m_udp_resolver.async_resolve(hostname.c_str(), std::to_string(port).c_str()
+ , [buf=std::move(forward_buffer), hostname, this]
+ (error_code const& ec, asio::ip::udp::resolver::results_type ips)
+ {
+ if (ec)
+ {
+ std::printf("resolve failed: %s\n", ec.message().c_str());
+ return;
+ }
+
+ for (auto const& ip : ips)
+ {
+ auto const target = ip.endpoint();
+ error_code err;
+ m_udp_associate.send_to(boost::asio::buffer(buf)
+ , target, 0, err);
+ if (!err)
+ {
+ m_name_mapping.insert({target.address(), hostname});
+ break;
+ }
+ std::printf("send_to failed: %s\n", err.message().c_str());
+ }
+ });
+ }
+ else if (atyp == 1)
+ {
+ // IPv4
+ std::uint32_t addr = buf[4] & 0xff;
+ addr <<= 8;
+ addr |= buf[5] & 0xff;
+ addr <<= 8;
+ addr |= buf[6] & 0xff;
+ addr <<= 8;
+ addr |= buf[7] & 0xff;
+
+ std::uint16_t port = buf[8] & 0xff;
+ port <<= 8;
+ port |= buf[9] & 0xff;
+
+ buf += 10;
+ bytes_transferred -= 10;
+
+ asio::ip::udp::endpoint const target(address_v4(addr), port);
+
+ error_code err;
+ m_udp_associate.send_to(boost::asio::buffer(buf, bytes_transferred), target, 0, err);
+ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
+ }
+ else
+ {
+ std::printf("only supports IPv4 and hostname. ATYP: %d\n", atyp);
+ }
+ }
+ else
+ {
+ std::uint16_t const from_port = m_udp_from.port();
+
+ auto it = m_name_mapping.left.find(m_udp_from.address());
+ if (it != m_name_mapping.left.end())
+ {
+ std::vector<char> header(7 + it->second.size());
+ header[0] = 0; // RSV
+ header[1] = 0;
+ header[2] = 0; // fragment
+ header[3] = 3; // ATYP
+ header[4] = static_cast<char>(it->second.size());
+ int idx = 5;
+ std::copy(it->second.begin(), it->second.end(), header.data() + idx);
+ idx += static_cast<int>(it->second.size());
+ header[idx] = (from_port >> 8) & 0xff;
+ header[idx + 1] = from_port & 0xff;
+
+ std::array<boost::asio::const_buffer, 2> vec{{
+ {header.data(), header.size()},
+ {m_udp_buffer.data(), bytes_transferred}}};
+
+ error_code err;
+ m_udp_associate.send_to(vec, m_udp_associate_ep, 0, err);
+ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
+ }
+ else
+ {
+ // add UDP ASSOCIATE header and forward to client
+ std::uint32_t const from_addr = m_udp_from.address().to_v4().to_uint();
+ std::array<char, 10> header;
+ header[0] = 0; // RSV
+ header[1] = 0;
+ header[2] = 0; // fragment
+ header[3] = 1; // ATYP
+ header[4] = (from_addr >> 24) & 0xff; // Address
+ header[5] = (from_addr >> 16) & 0xff;
+ header[6] = (from_addr >> 8) & 0xff;
+ header[7] = (from_addr) & 0xff;
+ header[8] = (from_port >> 8) & 0xff;
+ header[9] = from_port & 0xff;
+
+ std::array<boost::asio::const_buffer, 2> vec{{
+ {header.data(), header.size()},
+ {m_udp_buffer.data(), bytes_transferred}}};
+
+ error_code err;
+ m_udp_associate.send_to(vec, m_udp_associate_ep, 0, err);
+ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
+ }
+ }
+
+ m_udp_associate.async_receive_from(boost::asio::buffer(m_udp_buffer)
+ , m_udp_from, 0, std::bind(&socks_connection::on_read_udp, this, std::placeholders::_1, std::placeholders::_2));
+ }
+
+ void socks_connection::start_accept(boost::system::error_code const& ec)
+ {
+ if (ec)
+ {
+ std::printf("socks_connection(%s): error writing to client: (%d) %s\n"
+ , command(), ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ m_bind_socket.listen();
+ m_bind_socket.async_accept(m_server_connection
+ , std::bind(&socks_connection::on_connected
+ , shared_from_this(), std::placeholders::_1));
+
+ m_client_connection.async_read_some(
+ sim::asio::buffer(m_out_buffer)
+ , std::bind(&socks_connection::on_client_receive, shared_from_this()
+ , std::placeholders::_1, std::placeholders::_2));
+ }
+
+ int socks_connection::format_response(address const& addr, int const port
+ , int const response)
+ {
+ int i = 0;
+ if (m_version == 5)
+ {
+// +----+-----+-------+------+----------+----------+
+// |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
+// +----+-----+-------+------+----------+----------+
+// | 1 | 1 | X'00' | 1 | Variable | 2 |
+// +----+-----+-------+------+----------+----------+
+
+ m_in_buffer[i++] = char(m_version); // version
+ m_in_buffer[i++] = char(response); // response
+ m_in_buffer[i++] = 0; // reserved
+ if (addr.is_v4())
+ {
+ m_in_buffer[i++] = 1; // IPv4
+ address_v4::bytes_type b = addr.to_v4().to_bytes();
+ memcpy(&m_in_buffer[i], &b[0], b.size());
+ i += int(b.size());
+ } else {
+ m_in_buffer[i++] = 4; // IPv6
+ address_v6::bytes_type b = addr.to_v6().to_bytes();
+ memcpy(&m_in_buffer[i], &b[0], b.size());
+ i += int(b.size());
+ }
+
+ m_in_buffer[i++] = (port >> 8) & 0xff;
+ m_in_buffer[i++] = port & 0xff;
+ }
+ else
+ {
+ m_in_buffer[i++] = 0; // response version
+ m_in_buffer[i++] = char(response); // return code
+
+ assert(addr.is_v4());
+
+ m_in_buffer[i++] = (port >> 8) & 0xff;
+ m_in_buffer[i++] = port & 0xff;
+
+ address_v4::bytes_type b = addr.to_v4().to_bytes();
+ memcpy(&m_in_buffer[i], &b[0], b.size());
+ i += int(b.size());
+ }
+ return i;
+ }
+
+ int socks_connection::format_hostname_response(char const* hostname, int const port
+ , int const response)
+ {
+ int i = 0;
+ if (m_version != 5)
+ {
+ std::printf("socks_connection: hostname response requires SOCKS v5\n");
+ close_connection();
+ return 0;
+ }
+// +----+-----+-------+------+----------+----------+
+// |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
+// +----+-----+-------+------+----------+----------+
+// | 1 | 1 | X'00' | 1 | Variable | 2 |
+// +----+-----+-------+------+----------+----------+
+
+ m_in_buffer[i++] = char(m_version); // version
+ m_in_buffer[i++] = char(response); // response
+ m_in_buffer[i++] = 0; // reserved
+ m_in_buffer[i++] = 3; // DOMAINNAME
+ m_in_buffer[i++] = std::uint8_t(::strlen(hostname));
+ for (; *hostname != '\0'; ++hostname)
+ m_in_buffer[i++] = *hostname;
+
+ m_in_buffer[i++] = (port >> 8) & 0xff;
+ m_in_buffer[i++] = port & 0xff;
+ return i;
+ }
+
+ void socks_connection::on_connected(boost::system::error_code const& ec)
+ {
+ std::printf("socks_connection(%s): on_connect: (%d) %s\n"
+ , command(), ec.value(), ec.message().c_str());
+
+ if (ec == asio::error::operation_aborted
+ || ec == boost::system::errc::bad_file_descriptor)
+ {
+ return;
+ }
+
+ boost::system::error_code err;
+ asio::ip::tcp::endpoint const ep = m_server_connection.remote_endpoint(err);
+ if (!err)
+ {
+ std::printf("socks_connection(%s): remote_endpoint: %s %d\n"
+ , command(), ep.address().to_string().c_str(), ep.port());
+ }
+
+ int const response = ec
+ ? (m_version == 4 ? 91 : 5)
+ : (m_version == 4 ? 90 : 0);
+ int const len = format_response(ep.address(), ep.port(), response);
+
+ if (ec)
+ {
+ std::printf("socks_connection(%s): failed to connect to/accept from target server: (%d) %s\n"
+ , command(), ec.value(), ec.message().c_str());
+
+ auto self = shared_from_this();
+
+ asio::async_write(m_client_connection
+ , asio::buffer(&m_in_buffer[0], len)
+ , [=](boost::system::error_code const&, size_t)
+ {
+ self->close_connection();
+ });
+ return;
+ }
+
+ auto self = shared_from_this();
+
+ asio::async_write(m_client_connection
+ , asio::buffer(&m_in_buffer[0], len)
+ , [this, self](boost::system::error_code const& ec, size_t)
+ {
+ if (ec)
+ {
+ std::printf("socks_connection(%s): error writing to client: (%d) %s\n"
+ , command(), ec.value(), ec.message().c_str());
+ return;
+ }
+
+ // read from the client and from the server
+ self->m_server_connection.async_read_some(
+ sim::asio::buffer(m_in_buffer)
+ , std::bind(&socks_connection::on_server_receive, self
+ , std::placeholders::_1, std::placeholders::_2));
+ self->m_client_connection.async_read_some(
+ sim::asio::buffer(m_out_buffer)
+ , std::bind(&socks_connection::on_client_receive, self
+ , std::placeholders::_1, std::placeholders::_2));
+ });
+ }
+
+ // we received some data from the client, forward it to the server
+ void socks_connection::on_client_receive(boost::system::error_code const& ec
+ , std::size_t bytes_transferred)
+ {
+ // bad file descriptor means the socket has been closed. Whoever closed
+ // the socket will have opened a new one, we cannot call
+ // close_connection()
+ if (ec == asio::error::operation_aborted
+ || ec == boost::system::errc::bad_file_descriptor)
+ return;
+
+ if (ec)
+ {
+ std::printf("socks_connection (%s): error reading from client: (%d) %s\n"
+ , command(), ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+ asio::async_write(m_server_connection, asio::buffer(&m_out_buffer[0], bytes_transferred)
+ , std::bind(&socks_connection::on_client_forward, shared_from_this()
+ , std::placeholders::_1, std::placeholders::_2));
+ }
+
+ void socks_connection::on_client_forward(error_code const& ec
+ , size_t /* bytes_transferred */)
+ {
+ if (ec)
+ {
+ std::printf("socks_connection(%s): error writing to server: (%d) %s\n"
+ , command(), ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ m_client_connection.async_read_some(
+ sim::asio::buffer(m_out_buffer)
+ , std::bind(&socks_connection::on_client_receive, shared_from_this()
+ , std::placeholders::_1, std::placeholders::_2));
+ }
+
+ // we received some data from the server, forward it to the server
+ void socks_connection::on_server_receive(boost::system::error_code const& ec
+ , std::size_t bytes_transferred)
+ {
+ if (ec)
+ {
+ std::printf("socks_connection(%s): error reading from server: (%d) %s\n"
+ , command(), ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], bytes_transferred)
+ , std::bind(&socks_connection::on_server_forward, shared_from_this()
+ , std::placeholders::_1, std::placeholders::_2));
+ }
+
+ void socks_connection::on_server_forward(error_code const& ec
+ , size_t /* bytes_transferred */)
+ {
+ if (ec)
+ {
+ std::printf("socks_connection(%s): error writing to client: (%d) %s\n"
+ , command(), ec.value(), ec.message().c_str());
+ close_connection();
+ return;
+ }
+
+ m_server_connection.async_read_some(
+ sim::asio::buffer(m_in_buffer)
+ , std::bind(&socks_connection::on_server_receive, shared_from_this()
+ , std::placeholders::_1, std::placeholders::_2));
+ }
+
+ void socks_connection::close_connection()
+ {
+ error_code err;
+ m_client_connection.close(err);
+ if (err)
+ {
+ std::printf("socks_connection::close: failed to close client connection (%d) %s\n"
+ , err.value(), err.message().c_str());
+ }
+ m_server_connection.close(err);
+ if (err)
+ {
+ std::printf("socks_connection::close: failed to close server connection (%d) %s\n"
+ , err.value(), err.message().c_str());
+ }
+
+ m_bind_socket.close(err);
+ if (err)
+ {
+ std::printf("socks_connection::close: failed to close bind socket (%d) %s\n"
+ , err.value(), err.message().c_str());
+ }
+ }
+
+ char const* socks_connection::command() const
+ {
+ switch (m_command)
+ {
+ case 1: return "CONNECT";
+ case 2: return "BIND";
+ case 3: return "UDP_ASSOCIATE";
+ default: return "UNKNOWN";
+ }
+ }
+}
+
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include "simulator/packet.hpp"
+#include "simulator/pcap.hpp"
+#include "simulator/handler_allocator.hpp"
+
+#include <functional>
+#include <cinttypes>
+#include <cstdio> // for printf
+
+#include "simulator/push_warnings.hpp"
+#include <boost/system/error_code.hpp>
+#include <boost/function.hpp>
+#include "simulator/pop_warnings.hpp"
+
+typedef sim::chrono::high_resolution_clock::time_point time_point;
+typedef sim::chrono::high_resolution_clock::duration duration;
+
+using namespace std::placeholders;
+
+namespace sim {
+namespace asio {
+namespace ip {
+
+ tcp::socket::socket(io_context& ios)
+ : socket_base(ios)
+ , m_connect_timer(ios)
+ , m_recv_timer(ios)
+ {}
+
+ tcp::socket::socket(socket&& s)
+ : socket_base(std::move(s))
+ , m_connect_handler(std::move(s.m_connect_handler))
+ , m_connect_timer(std::move(s.m_connect_timer))
+ , m_mss(s.m_mss)
+ , m_send_handler(std::move(s.m_send_handler))
+ , m_wait_send_handler(std::move(s.m_wait_send_handler))
+ , m_send_buffer(std::move(s.m_send_buffer))
+ , m_incoming_queue(std::move(s.m_incoming_queue))
+ , m_queue_size(std::move(s.m_queue_size))
+ , m_recv_handler(std::move(s.m_recv_handler))
+ , m_wait_recv_handler(std::move(s.m_wait_recv_handler))
+ , m_recv_buffer(std::move(s.m_recv_buffer))
+ , m_recv_timer(std::move(s.m_recv_timer))
+ , m_is_v4(std::move(s.m_is_v4))
+ , m_recv_null_buffers(std::move(s.m_recv_null_buffers))
+ , m_send_null_buffers(std::move(s.m_send_null_buffers))
+ , m_channel(std::move(s.m_channel))
+ , m_next_outgoing_seq(std::move(s.m_next_outgoing_seq))
+ , m_next_incoming_seq(std::move(s.m_next_incoming_seq))
+ , m_last_drop_seq(std::move(s.m_last_drop_seq))
+ , m_cwnd(std::move(s.m_cwnd))
+ , m_bytes_in_flight(std::move(s.m_bytes_in_flight))
+ , m_reorder_buffer(std::move(s.m_reorder_buffer))
+ , m_outstanding_packet_sizes(std::move(s.m_outstanding_packet_sizes))
+ , m_outgoing_packets(std::move(s.m_outgoing_packets))
+ {
+ if (m_forwarder) m_forwarder->reset(this);
+ s.m_forwarder.reset();
+ s.m_open = false;
+ s.m_bound_to = ip::tcp::endpoint();
+
+ if (m_bound_to != ip::tcp::endpoint())
+ m_io_service.rebind_socket(&s, this, m_bound_to);
+ }
+
+ tcp::socket::~socket()
+ {
+ boost::system::error_code ec;
+
+ m_channel.reset();
+
+ if (m_bound_to != ip::tcp::endpoint())
+ {
+ m_io_service.unbind_socket(this, m_bound_to);
+ m_bound_to = ip::tcp::endpoint();
+ m_user_bound_to = ip::tcp::endpoint();
+ }
+ m_open = false;
+
+ // prevent any more packets from being delivered to this socket
+ if (m_forwarder)
+ {
+ m_forwarder->reset();
+ m_forwarder.reset();
+ }
+ cancel(ec);
+ }
+
+ void tcp::socket::open(tcp protocol, boost::system::error_code& ec) try
+ {
+ close(ec);
+ m_open = true;
+ m_is_v4 = (protocol == ip::tcp::v4());
+ ec.clear();
+ m_forwarder = std::make_shared<aux::sink_forwarder>(this);
+ }
+ catch (std::bad_alloc const&)
+ {
+ ec = make_error_code(boost::system::errc::not_enough_memory);
+ }
+ catch (boost::system::system_error const& err)
+ {
+ ec = err.code();
+ }
+
+ void tcp::socket::open(tcp protocol)
+ {
+ boost::system::error_code ec;
+ open(protocol, ec);
+ if (ec) throw boost::system::system_error(ec);
+ }
+
+ // used to attach an incoming connection to this
+ void tcp::socket::internal_connect(tcp::endpoint const& bind_ip
+ , std::shared_ptr<aux::channel> const& c
+ , boost::system::error_code& ec)
+ {
+ open(m_is_v4 ? tcp::v4() : tcp::v6(), ec);
+ if (ec)
+ {
+ std::printf("tcp::socket::internal_connect() error: (%d) %s\n"
+ , ec.value(), ec.message().c_str());
+ return;
+ }
+ m_bound_to = bind_ip;
+ m_user_bound_to = bind_ip;
+ m_channel = c;
+ assert(m_forwarder);
+ c->hops[1].replace_last(m_forwarder);
+ }
+
+ void tcp::socket::bind(ip::tcp::endpoint const& ep
+ , boost::system::error_code& ec) try
+ {
+ if (!m_open)
+ {
+ ec = error::bad_descriptor;
+ return;
+ }
+
+ if (ep.address().is_v4() != m_is_v4)
+ {
+ ec = error::address_family_not_supported;
+ return;
+ }
+
+ ip::tcp::endpoint addr = m_io_service.bind_socket(this, ep, ec);
+ if (ec) return;
+ m_bound_to = addr;
+ m_user_bound_to = addr;
+ }
+ catch (std::bad_alloc const&)
+ {
+ ec = make_error_code(boost::system::errc::not_enough_memory);
+ }
+ catch (boost::system::system_error const& err)
+ {
+ ec = err.code();
+ }
+
+ void tcp::socket::bind(ip::tcp::endpoint const& ep)
+ {
+ boost::system::error_code ec;
+ bind(ep, ec);
+ if (ec) throw boost::system::system_error(ec);
+ }
+
+ void tcp::socket::close()
+ {
+ boost::system::error_code ec;
+ close(ec);
+ if (ec) throw boost::system::system_error(ec);
+ }
+
+ void tcp::socket::close(boost::system::error_code& ec) try
+ {
+ if (m_channel)
+ {
+ int const remote = m_channel->remote_idx(m_bound_to);
+ route hops = m_channel->hops[remote];
+
+ // if m_connect_handler is still set, it means the connection hasn't
+ // been established yet, and this channel points to the acceptor
+ // socket, not another open TCP connection.
+ if (!hops.empty() && !m_connect_handler)
+ {
+ aux::packet p;
+ p.type = aux::packet::type_t::error;
+ p.ec = asio::error::eof;
+ p.from = asio::ip::udp::endpoint(
+ m_bound_to.address(), m_bound_to.port());
+ p.overhead = 40;
+ p.hops = hops;
+ p.seq_nr = m_next_outgoing_seq++;
+ send_packet(std::move(p));
+ }
+ m_channel.reset();
+ }
+
+ if (m_bound_to != ip::tcp::endpoint())
+ {
+ m_io_service.unbind_socket(this, m_bound_to);
+ m_bound_to = ip::tcp::endpoint();
+ m_user_bound_to = ip::tcp::endpoint();
+ }
+ m_open = false;
+
+ // prevent any more packets from being delivered to this socket
+ if (m_forwarder)
+ {
+ m_forwarder->reset();
+ m_forwarder.reset();
+ }
+
+ // reset socket state
+ m_queue_size = 0;
+ m_mss = 1475;
+ m_cwnd = m_mss * 2;
+ m_bytes_in_flight = 0;
+ m_outstanding_packet_sizes.clear();
+ m_recv_null_buffers = false;
+ m_send_null_buffers = false;
+ m_next_incoming_seq = 0;
+ m_next_outgoing_seq = 0;
+ m_last_drop_seq = 0;
+
+ cancel(ec);
+
+ ec.clear();
+ }
+ catch (std::bad_alloc const&)
+ {
+ ec = make_error_code(boost::system::errc::not_enough_memory);
+ }
+ catch (boost::system::system_error const& err)
+ {
+ ec = err.code();
+ }
+
+ std::size_t tcp::socket::available(boost::system::error_code& ec) const
+ {
+ if (!m_open)
+ {
+ ec = boost::system::error_code(error::bad_descriptor);
+ return 0;
+ }
+ if (!m_channel)
+ {
+ ec = boost::system::error_code(error::not_connected);
+ return 0;
+ }
+ if (m_incoming_queue.empty())
+ {
+ return 0;
+ }
+
+ std::size_t ret = 0;
+ for (aux::packet const& p : m_incoming_queue)
+ {
+ if (p.type == aux::packet::type_t::error)
+ {
+ if (ret > 0) return ret;
+
+ // if the read buffer is drained and there is an error, report that
+ // error.
+ ec = p.ec;
+ return 0;
+ }
+ ret += p.buffer.size();
+ }
+ return ret;
+ }
+
+ std::size_t tcp::socket::available() const
+ {
+ boost::system::error_code ec;
+ std::size_t ret = available(ec);
+ if (ec) throw boost::system::system_error(ec);
+ return ret;
+ }
+
+ void tcp::socket::cancel(boost::system::error_code&)
+ {
+ abort_recv_handlers();
+ abort_send_handlers();
+
+ if (m_connect_handler)
+ {
+ post(m_io_service, aux::make_malloc(std::bind(std::move(m_connect_handler)
+ , boost::system::error_code(error::operation_aborted))));
+ m_connect_handler = nullptr;
+ }
+ }
+
+ void tcp::socket::cancel()
+ {
+ boost::system::error_code ec;
+ cancel(ec);
+ if (ec) throw boost::system::system_error(ec);
+ }
+
+ tcp::endpoint tcp::socket::remote_endpoint(boost::system::error_code& ec) const
+ {
+ if (!m_open)
+ {
+ ec = error::bad_descriptor;
+ return tcp::endpoint();
+ }
+
+ if (!m_channel)
+ {
+ ec = error::not_connected;
+ return tcp::endpoint();
+ }
+
+ int const remote = m_channel->remote_idx(m_bound_to);
+ return m_channel->visible_ep[remote];
+ }
+
+ tcp::endpoint tcp::socket::remote_endpoint() const
+ {
+ boost::system::error_code ec;
+ tcp::endpoint ret = remote_endpoint(ec);
+ if (ec) throw boost::system::system_error(ec);
+ return ret;
+ }
+
+ void tcp::socket::async_connect(tcp::endpoint const& target
+ , aux::function<void(boost::system::error_code const&)> h)
+ {
+ if (!m_open) open(target.protocol());
+
+ assert(h);
+ assert(!m_connect_handler);
+
+ // find remote socket
+ boost::system::error_code ec;
+ if (m_bound_to.address() == ip::address())
+ {
+ auto endpoint = ip::tcp::endpoint();
+ if (target.address().is_v4()) {
+ endpoint.address(ip::address_v4::any());
+ } else {
+ endpoint.address(ip::address_v6::any());
+ }
+ ip::tcp::endpoint addr = m_io_service.bind_socket(this
+ , endpoint, ec);
+ if (ec)
+ {
+ post(m_io_service, aux::make_malloc(std::bind(std::move(h), ec)));
+ return;
+ }
+ m_bound_to = addr;
+ m_user_bound_to = addr;
+ }
+ if (m_bound_to.address().is_v4() != target.address().is_v4())
+ {
+ post(m_io_service, aux::make_malloc(std::bind(std::move(h),
+ boost::system::error_code(error::address_family_not_supported))));
+ return;
+ }
+ m_channel = m_io_service.internal_connect(this, target, ec);
+ m_mss = m_io_service.get_path_mtu(m_bound_to.address(), target.address());
+ m_cwnd = m_mss * 2;
+ if (ec)
+ {
+ m_channel.reset();
+ // TODO: ask the policy object what the round-trip to this endpoint is
+ m_connect_timer.expires_after(chrono::milliseconds(50));
+ m_connect_timer.async_wait(aux::make_malloc(std::bind(std::move(h), ec)));
+ return;
+ }
+
+ m_connect_handler = std::move(h);
+
+ // the acceptor socket will call internal_connect_complete once the
+ // connection is established
+ }
+
+ void tcp::socket::abort_recv_handlers()
+ {
+ if (m_recv_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_recv_handler)
+ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
+
+ if (m_wait_recv_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_wait_recv_handler)
+ , boost::system::error_code(error::operation_aborted))));
+
+ m_recv_timer.cancel();
+ m_recv_handler = nullptr;
+ m_wait_recv_handler = nullptr;
+ m_recv_buffer.clear();
+ m_recv_null_buffers = false;
+ }
+
+ void tcp::socket::abort_send_handlers()
+ {
+ if (m_send_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_send_handler)
+ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
+
+ if (m_wait_send_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_wait_send_handler)
+ , boost::system::error_code(error::operation_aborted))));
+
+ m_send_handler = nullptr;
+ m_wait_send_handler = nullptr;
+ m_send_buffer.clear();
+ m_send_null_buffers = false;
+ }
+
+ void tcp::socket::async_write_some_impl(std::vector<boost::asio::const_buffer> const& bufs
+ , aux::function<void(boost::system::error_code const&, std::size_t)> handler)
+ {
+ boost::system::error_code ec;
+ std::size_t const bytes_transferred = write_some_impl(bufs, ec);
+ if (ec == boost::system::error_code(error::would_block))
+ {
+ m_send_handler = std::move(handler);
+ m_send_buffer = bufs;
+ return;
+ }
+
+ if (ec)
+ {
+ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec, std::size_t(0))));
+ m_send_handler = nullptr;
+ m_send_buffer.clear();
+ return;
+ }
+
+ boost::system::error_code no_error;
+ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), no_error
+ , bytes_transferred)));
+ m_send_handler = nullptr;
+ m_send_buffer.clear();
+ }
+
+ std::size_t tcp::socket::write_some_impl(
+ std::vector<boost::asio::const_buffer> const& bufs
+ , boost::system::error_code& ec)
+ {
+ if (!m_open)
+ {
+ ec = boost::system::error_code(error::bad_descriptor);
+ return 0;
+ }
+ if (!m_channel)
+ {
+ ec = boost::system::error_code(error::not_connected);
+ return 0;
+ }
+
+ // the connect handler is used as proxy that this socket has not competed
+ // the connection yet. We're still waiting for SYN+ACK
+ if (m_connect_handler)
+ {
+ ec = boost::system::error_code(error::would_block);
+ return 0;
+ }
+
+ int const remote = m_channel->remote_idx(m_bound_to);
+ route hops = m_channel->hops[remote];
+ if (hops.empty())
+ {
+ ec = boost::system::error_code(error::not_connected);
+ return 0;
+ }
+
+ if (m_bytes_in_flight + m_mss > m_cwnd)
+ {
+ // this indicates that the send buffer is very large, we should
+ // probably not be able to stuff more bytes down it
+ // wait for the receiving end to pop some bytes off
+ ec = boost::system::error_code(error::would_block);
+ return 0;
+ }
+
+ std::size_t ret = 0;
+
+ for (auto const& buf : bufs)
+ {
+ // split up in packets
+ int buf_size = int(buf.size());
+ std::uint8_t const* ptr = static_cast<std::uint8_t const*>(buf.data());
+ while (buf_size > 0)
+ {
+ int packet_size = (std::min)(buf_size, m_mss);
+ aux::packet p;
+ p.type = aux::packet::type_t::payload;
+ p.buffer.assign(ptr, ptr + packet_size);
+ p.from = asio::ip::udp::endpoint(
+ m_bound_to.address(), m_bound_to.port());
+ p.overhead = 40;
+ p.hops = hops;
+ p.seq_nr = m_next_outgoing_seq++;
+ p.drop_fun = std::bind(&tcp::socket::packet_dropped, this, _1);
+
+ send_packet(std::move(p));
+ ptr += packet_size;
+ buf_size -= packet_size;
+ ret += packet_size;
+
+ if (m_bytes_in_flight + m_mss > m_cwnd)
+ {
+ // the congestion window is full
+ if (ret == 0)
+ {
+ ec = boost::system::error_code(error::would_block);
+ return 0;
+ }
+
+ return ret;
+ }
+ }
+ }
+
+ return ret;
+ }
+
+ std::size_t tcp::socket::read_some_impl(
+ std::vector<boost::asio::mutable_buffer> const& bufs
+ , boost::system::error_code& ec)
+ {
+ // a zero-sized read always completes immediately with 0 bytes;
+ // boost.asio's SSL implementation relies on this to post a
+ // completion handler without transferring any data.
+ if (boost::asio::buffer_size(bufs) == 0)
+ {
+ ec.clear();
+ return 0;
+ }
+
+ assert(!bufs.empty());
+ if (!m_open)
+ {
+ ec = boost::system::error_code(error::bad_descriptor);
+ return 0;
+ }
+ if (!m_channel)
+ {
+ ec = boost::system::error_code(error::not_connected);
+ return 0;
+ }
+ if (m_connect_handler)
+ {
+ // the socket is not done connecting yet
+ ec = boost::system::error_code(error::would_block);
+ return 0;
+ }
+
+ if (m_incoming_queue.empty())
+ {
+ ec = boost::system::error_code(error::would_block);
+ return 0;
+ }
+
+ typedef std::vector<boost::asio::mutable_buffer> buffers_t;
+ m_recv_buffer = bufs;
+ buffers_t::iterator recv_iter = m_recv_buffer.begin();
+ int total_received = 0;
+ // the offset in the current receive buffer we're writing to. i.e. the
+ // buffer recv_iter points to
+ int buf_offset = 0;
+
+ while (!m_incoming_queue.empty())
+ {
+ aux::packet& p = m_incoming_queue.front();
+
+ if (p.type == aux::packet::type_t::error)
+ {
+ // if we have received bytes also, first deliver those. In the next
+ // read, deliver the error
+ if (total_received > 0) break;
+
+ assert(p.ec);
+ ec = p.ec;
+ m_incoming_queue.erase(m_incoming_queue.begin());
+ m_channel.reset();
+ return 0;
+ }
+ else if (p.type == aux::packet::type_t::payload)
+ {
+ // copy bytes from the incoming queue into the receive buffer.
+ // both are vectors of buffer, so it can get a bit hairy
+ while (recv_iter != m_recv_buffer.end())
+ {
+ int const buf_size = int(recv_iter->size());
+ int const copy_size = (std::min)(int(p.buffer.size())
+ , buf_size - buf_offset);
+
+ memcpy(static_cast<char*>(recv_iter->data()) + buf_offset
+ , p.buffer.data(), copy_size);
+
+ p.buffer.erase(p.buffer.begin(), p.buffer.begin() + copy_size);
+ m_queue_size -= copy_size;
+
+ buf_offset += copy_size;
+ assert(buf_offset <= buf_size);
+ total_received += copy_size;
+ if (buf_offset == buf_size)
+ {
+ ++recv_iter;
+ buf_offset = 0;
+ }
+
+ if (p.buffer.empty())
+ {
+ m_incoming_queue.erase(m_incoming_queue.begin());
+ break;
+ }
+ }
+ }
+ else
+ {
+ assert(false);
+ }
+
+ if (recv_iter == m_recv_buffer.end())
+ break;
+ }
+
+ assert(total_received > 0);
+
+ ec.clear();
+ return total_received;
+ }
+
+ void tcp::socket::async_read_some_impl(std::vector<boost::asio::mutable_buffer> const& bufs
+ , aux::function<void(boost::system::error_code const&, std::size_t)> handler)
+ {
+ // a zero-sized read always completes immediately with 0 bytes
+ // transferred, regardless of connection or queue state. boost.asio's
+ // SSL implementation relies on this to bounce a completion handler
+ // through the executor without actually transferring any data.
+ if (boost::asio::buffer_size(bufs) == 0)
+ {
+ post(m_io_service, aux::make_malloc(std::bind(std::move(handler)
+ , boost::system::error_code(), std::size_t(0))));
+ return;
+ }
+
+ assert(!bufs.empty());
+
+ boost::system::error_code ec;
+ std::size_t bytes_transferred = read_some_impl(bufs, ec);
+ if (ec == boost::system::error_code(error::would_block))
+ {
+ assert(m_incoming_queue.empty());
+
+ m_recv_buffer = bufs;
+ m_recv_handler = std::move(handler);
+ m_recv_null_buffers = false;
+ return;
+ }
+
+ if (ec)
+ {
+ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec, std::size_t(0))));
+ m_recv_handler = nullptr;
+ m_recv_buffer.clear();
+ return;
+ }
+
+ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec, bytes_transferred)));
+ m_recv_handler = nullptr;
+ m_recv_buffer.clear();
+ }
+
+ void tcp::socket::async_wait_read_impl(
+ aux::function<void(boost::system::error_code const&)> handler)
+ {
+ boost::system::error_code ec;
+ // null_buffers notifies the handler when data is available, without
+ // reading any
+ int const bytes = int(available(ec));
+ if (ec)
+ {
+ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
+ m_recv_handler = nullptr;
+ m_recv_buffer.clear();
+ return;
+ }
+
+ if (bytes > 0)
+ {
+ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
+ m_recv_handler = nullptr;
+ m_recv_buffer.clear();
+ return;
+ }
+
+ m_wait_recv_handler = std::move(handler);
+ m_recv_null_buffers = true;
+ }
+
+ void tcp::socket::async_wait_write_impl(
+ aux::function<void(boost::system::error_code const&)> handler)
+ {
+ if (!m_open)
+ {
+ boost::system::error_code const ec(error::bad_descriptor);
+ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
+ return;
+ }
+
+ if (!m_channel)
+ {
+ boost::system::error_code const ec(error::not_connected);
+ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
+ return;
+ }
+
+ if (!m_connect_handler && m_bytes_in_flight + m_mss <= m_cwnd)
+ {
+ // the socket is writable right now. complete immediately without
+ // actually writing anything, this is the null_buffers equivalent
+ // for writes
+ boost::system::error_code const ec;
+ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
+ return;
+ }
+
+ m_wait_send_handler = std::move(handler);
+ m_send_null_buffers = true;
+ }
+
+ // if there is an outstanding read operation, and this was the first incoming
+ // operation since we last drained, wake up the reader
+ void tcp::socket::maybe_wakeup_reader()
+ {
+ if (m_incoming_queue.size() != 1 || (!m_recv_handler && !m_wait_recv_handler)) return;
+
+ if (m_recv_null_buffers)
+ {
+ async_wait_read_impl(std::move(m_wait_recv_handler));
+ }
+ else
+ {
+ // we have an async. read operation outstanding, and we just put one
+ // packet in our incoming queue.
+
+ // try to read from it and potentially fire the handler
+ async_read_some_impl(m_recv_buffer, std::move(m_recv_handler));
+ }
+ }
+
+ void tcp::socket::maybe_wakeup_writer()
+ {
+ if (!m_send_handler && !m_wait_send_handler) return;
+
+ if (m_send_null_buffers)
+ {
+ async_wait_write_impl(std::move(m_wait_send_handler));
+ }
+ else
+ {
+ // we have an async. write operation outstanding
+ async_write_some_impl(m_send_buffer, std::move(m_send_handler));
+ }
+ }
+
+ bool tcp::socket::internal_is_listening() { return false; }
+
+ void tcp::socket::send_packet(aux::packet p)
+ {
+ m_bytes_in_flight += int(p.buffer.size());
+ m_outstanding_packet_sizes[p.seq_nr] = int(p.buffer.size());
+
+ int const idx = m_channel->self_idx(m_bound_to);
+ p.byte_counter = m_channel->bytes_sent[idx];
+ m_channel->bytes_sent[idx] += std::uint32_t(p.buffer.size());
+
+ auto* log = m_io_service.sim().get_pcap();
+ if (log)
+ {
+ int const remote = m_channel->remote_idx(m_bound_to);
+ log->log_tcp(p, m_bound_to, m_channel->ep[remote]);
+ }
+
+ forward_packet(std::move(p));
+ }
+
+ void tcp::socket::packet_dropped(aux::packet p)
+ {
+ int remote = m_channel->remote_idx(m_bound_to);
+ p.hops = m_channel->hops[remote];
+ m_outgoing_packets.push_back(std::move(p));
+
+ const int packets_in_cwnd = m_cwnd / m_mss;
+
+ // we just recently dropped a packet and cut the cwnd in half,
+ // don't do it again already
+ if (m_last_drop_seq > 0 && p.seq_nr < m_last_drop_seq + packets_in_cwnd) return;
+
+ m_cwnd /= 2;
+ m_last_drop_seq = p.seq_nr;
+
+ // TODO: this should really happen one second later to be accurate
+ if (m_cwnd < m_mss) m_cwnd = m_mss;
+ }
+
+ void tcp::socket::incoming_packet(aux::packet p)
+ {
+ switch (p.type)
+ {
+ case aux::packet::type_t::uninitialized:
+ {
+ assert(false && "uninitialized packet");
+ return;
+ }
+ case aux::packet::type_t::ack:
+ {
+ // if the socket just became writeable, we need to notify the
+ // client. First we want to know whether it was not writeable.
+ const bool was_writeable = m_bytes_in_flight + m_mss > m_cwnd;
+
+ auto it = m_outstanding_packet_sizes.find(p.seq_nr);
+ assert(it != m_outstanding_packet_sizes.end());
+ const int acked_bytes = it->second;
+ m_outstanding_packet_sizes.erase(it);
+ assert(m_bytes_in_flight >= acked_bytes);
+ m_bytes_in_flight -= acked_bytes;
+
+ // potentially resend packets
+ while (!m_outgoing_packets.empty()
+ && m_bytes_in_flight
+ + int(m_outgoing_packets.front().buffer.size()) <= m_cwnd)
+ {
+ aux::packet pkt = std::move(m_outgoing_packets.front());
+ m_outgoing_packets.erase(m_outgoing_packets.begin());
+ send_packet(std::move(pkt));
+ }
+
+ // update cwnd based on the number of bytes ACKed.
+ // every round-trip, increase the window size by one packet
+ // (MSS)
+ m_cwnd += m_mss * acked_bytes / m_cwnd;
+
+ // TODO: implement slow-start
+
+ const bool is_writeable = m_bytes_in_flight + m_mss <= m_cwnd;
+
+ if (!was_writeable && is_writeable)
+ maybe_wakeup_writer();
+
+ return;
+ }
+ case aux::packet::type_t::syn:
+ {
+ // TODO: return connection refused
+ return;
+ }
+ case aux::packet::type_t::syn_ack:
+ {
+ assert(m_connect_handler);
+ boost::system::error_code ec;
+ post(m_io_service, aux::make_malloc(std::bind(std::move(m_connect_handler), ec)));
+ m_connect_handler = nullptr;
+ if (ec) m_channel.reset();
+ else maybe_wakeup_writer();
+ return;
+ }
+ case aux::packet::type_t::error:
+ case aux::packet::type_t::payload:
+ {
+ aux::packet ack;
+ ack.type = aux::packet::type_t::ack;
+ ack.seq_nr = p.seq_nr;
+
+ int remote = m_channel->remote_idx(m_bound_to);
+ ack.hops = m_channel->hops[remote];
+ forward_packet(std::move(ack));
+
+ // if the sequence number is out-of-order, put it in the
+ // m_incoming_packets queue
+ if (p.seq_nr != m_next_incoming_seq)
+ {
+ if (p.seq_nr < m_next_incoming_seq)
+ {
+ std::printf("TCP: incoming sequence number lower (%" PRId64 ") "
+ "than expected: %" PRId64 "\n", p.seq_nr, m_next_incoming_seq);
+ }
+
+ m_reorder_buffer.emplace(p.seq_nr, std::move(p));
+ return;
+ }
+
+ // this packet was in-order. increment the expected next sequence
+ // number.
+ ++m_next_incoming_seq;
+ m_incoming_queue.push_back(std::move(p));
+
+ // also, perhaps there are some packets that arrived out-of-order,
+ // check to see
+ auto it = m_reorder_buffer.find(m_next_incoming_seq);
+ while (it != m_reorder_buffer.end())
+ {
+ aux::packet pkt = std::move(it->second);
+ m_reorder_buffer.erase(it);
+ m_incoming_queue.push_back(std::move(pkt));
+ ++m_next_incoming_seq;
+ it = m_reorder_buffer.find(m_next_incoming_seq);
+ }
+
+ maybe_wakeup_reader();
+ return;
+ }
+ }
+ }
+}
+}
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include "simulator/packet.hpp"
+#include "simulator/pcap.hpp"
+#include "simulator/handler_allocator.hpp"
+
+#include <functional>
+
+#include "simulator/push_warnings.hpp"
+#include <boost/system/error_code.hpp>
+#include <boost/function.hpp>
+#include "simulator/pop_warnings.hpp"
+
+typedef sim::chrono::high_resolution_clock::time_point time_point;
+typedef sim::chrono::high_resolution_clock::duration duration;
+
+namespace sim {
+namespace asio {
+namespace ip {
+
+ udp::socket::socket(io_context& ios)
+ : socket_base(ios)
+ , m_next_send(chrono::high_resolution_clock::now())
+ , m_recv_sender(nullptr)
+ , m_recv_timer(ios)
+ , m_send_timer(ios)
+ , m_recv_null_buffers(0)
+ , m_queue_size(0)
+ , m_is_v4(true)
+ {}
+
+ udp::socket::socket(socket&& s)
+ : socket_base(std::move(s))
+ , m_next_send(std::move(s.m_next_send))
+ , m_send_handler(std::move(s.m_send_handler))
+ , m_wait_send_handler(std::move(s.m_wait_send_handler))
+ , m_recv_handler(std::move(s.m_recv_handler))
+ , m_wait_recv_handler(std::move(s.m_wait_recv_handler))
+ , m_recv_buffer(std::move(s.m_recv_buffer))
+ , m_recv_sender(std::move(s.m_recv_sender))
+ , m_recv_timer(std::move(s.m_recv_timer))
+ , m_send_timer(std::move(s.m_send_timer))
+ , m_incoming_queue(std::move(s.m_incoming_queue))
+ , m_recv_null_buffers(std::move(s.m_recv_null_buffers))
+ , m_queue_size(std::move(s.m_queue_size))
+ , m_is_v4(s.m_is_v4)
+ {
+ if (m_forwarder) m_forwarder->reset(this);
+ s.m_forwarder.reset();
+ s.m_open = false;
+ s.m_bound_to = ip::udp::endpoint();
+ if (m_bound_to != ip::udp::endpoint())
+ m_io_service.rebind_udp_socket(this, m_bound_to);
+ }
+
+ udp::socket::~socket()
+ {
+ boost::system::error_code ec;
+ close(ec);
+ }
+
+ void udp::socket::bind(ip::udp::endpoint const& ep
+ , boost::system::error_code& ec) try
+ {
+ if (!m_open)
+ {
+ ec = error::bad_descriptor;
+ return;
+ }
+
+ if (ep.address().is_v4() != m_is_v4)
+ {
+ ec = error::address_family_not_supported;
+ return;
+ }
+
+ ip::udp::endpoint addr = m_io_service.bind_udp_socket(this, ep, ec);
+ if (ec) return;
+ m_bound_to = addr;
+ m_user_bound_to = addr;
+ }
+ catch (std::bad_alloc const&)
+ {
+ ec = make_error_code(boost::system::errc::not_enough_memory);
+ }
+ catch (boost::system::system_error const& err)
+ {
+ ec = err.code();
+ }
+
+ void udp::socket::bind(ip::udp::endpoint const& ep)
+ {
+ boost::system::error_code ec;
+ bind(ep, ec);
+ if (ec) throw boost::system::system_error(ec);
+ }
+
+ void udp::socket::open(udp protocol
+ , boost::system::error_code& ec) try
+ {
+ // TODO: what if it's already open?
+ close(ec);
+ m_open = true;
+ m_is_v4 = (protocol == ip::udp::v4());
+ m_forwarder = std::make_shared<aux::sink_forwarder>(this);
+ }
+ catch (std::bad_alloc const&)
+ {
+ ec = make_error_code(boost::system::errc::not_enough_memory);
+ }
+ catch (boost::system::system_error const& err)
+ {
+ ec = err.code();
+ }
+
+ void udp::socket::open(udp protocol)
+ {
+ boost::system::error_code ec;
+ open(protocol, ec);
+ if (ec) throw boost::system::system_error(ec);
+ }
+
+ void udp::socket::close()
+ {
+ boost::system::error_code ec;
+ close(ec);
+ if (ec) throw boost::system::system_error(ec);
+ }
+
+ void udp::socket::close(boost::system::error_code& ec) try
+ {
+ if (m_bound_to != ip::udp::endpoint())
+ {
+ m_io_service.unbind_udp_socket(this, m_bound_to);
+ m_bound_to = ip::udp::endpoint();
+ m_user_bound_to = ip::udp::endpoint();
+ }
+ m_open = false;
+
+ // prevent any more packets from being delivered to this socket
+ if (m_forwarder)
+ {
+ m_forwarder->reset();
+ m_forwarder.reset();
+ }
+
+ cancel(ec);
+ }
+ catch (std::bad_alloc const&)
+ {
+ ec = make_error_code(boost::system::errc::not_enough_memory);
+ }
+ catch (boost::system::system_error const& err)
+ {
+ ec = err.code();
+ }
+
+ void udp::socket::cancel(boost::system::error_code&)
+ {
+ // cancel outstanding async operations
+ abort_recv_handlers();
+ abort_send_handlers();
+ m_recv_timer.cancel();
+ m_send_timer.cancel();
+ return;
+ }
+
+ void udp::socket::cancel()
+ {
+ boost::system::error_code ec;
+ cancel(ec);
+ if (ec) throw boost::system::system_error(ec);
+ }
+
+ void udp::socket::abort_send_handlers()
+ {
+ if (m_send_handler)
+ post(m_io_service, make_malloc(std::bind(std::ref(m_send_handler)
+ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
+
+ if (m_wait_send_handler)
+ post(m_io_service, make_malloc(std::bind(std::ref(m_wait_send_handler)
+ , boost::system::error_code(error::operation_aborted))));
+
+ m_send_timer.cancel();
+ m_send_handler = nullptr;
+ m_wait_send_handler = nullptr;
+// m_send_buffer.clear();
+ }
+
+ void udp::socket::abort_recv_handlers()
+ {
+ if (m_recv_handler)
+ post(m_io_service, make_malloc(std::bind(std::move(m_recv_handler)
+ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
+
+ if (m_wait_recv_handler)
+ post(m_io_service, make_malloc(std::bind(std::move(m_wait_recv_handler)
+ , boost::system::error_code(error::operation_aborted))));
+
+ m_recv_timer.cancel();
+ m_recv_handler = nullptr;
+ m_wait_recv_handler = nullptr;
+ m_recv_buffer.clear();
+ }
+
+ void udp::socket::async_wait(socket_base::wait_type_t const w
+ , aux::function<void(boost::system::error_code const&)> handler)
+ {
+ if (w == wait_type_t::wait_write)
+ {
+ abort_send_handlers();
+
+ time_point const now = chrono::high_resolution_clock::now();
+ boost::system::error_code no_error;
+ if (m_next_send - now > m_send_queue_time / 2)
+ {
+ // our send queue is too large. Defer
+ m_recv_timer.expires_at(m_next_send + m_send_queue_time / 2);
+
+ m_wait_send_handler = std::move(handler);
+ m_recv_timer.async_wait(make_malloc(std::bind(std::ref(m_wait_send_handler), no_error)));
+ return;
+ }
+
+ // the socket is writable, post the completion handler immediately
+ post(m_io_service, make_malloc(std::bind(std::move(handler), no_error)));
+ }
+ else if (w == wait_type_t::wait_read)
+ {
+ abort_recv_handlers();
+ async_wait_receive_impl(nullptr, std::move(handler));
+ }
+ }
+
+ std::size_t udp::socket::receive_from_impl(
+ std::vector<asio::mutable_buffer> const& bufs
+ , udp::endpoint* sender
+ , socket_base::message_flags /* flags */
+ , boost::system::error_code& ec)
+ {
+ assert(!bufs.empty());
+ if (!m_open)
+ {
+ ec = boost::system::error_code(error::bad_descriptor);
+ return 0;
+ }
+
+ if (m_bound_to == udp::endpoint())
+ {
+ ec = boost::system::error_code(error::invalid_argument);
+ return 0;
+ }
+
+ if (m_incoming_queue.empty())
+ {
+ ec = boost::system::error_code(error::would_block);
+ return 0;
+ }
+
+ aux::packet& p = m_incoming_queue.front();
+ if (sender) *sender = p.from;
+
+ int read = 0;
+ for (auto const& buf : bufs)
+ {
+ char* ptr = static_cast<char*>(buf.data());
+ int const len = int(buf.size());
+ int const to_copy = (std::min)(int(p.buffer.size()), len);
+ memcpy(ptr, p.buffer.data(), to_copy);
+ read += to_copy;
+ p.buffer.erase(p.buffer.begin(), p.buffer.begin() + to_copy);
+ m_queue_size -= to_copy;
+ if (p.buffer.empty()) break;
+ }
+
+ m_incoming_queue.erase(m_incoming_queue.begin());
+ return read;
+ }
+
+ void udp::socket::async_wait_receive_impl(
+ udp::endpoint* sender
+ , aux::function<void(boost::system::error_code const&)> handler)
+ {
+ if (!m_open)
+ {
+ post(m_io_service, make_malloc(std::bind(std::move(handler)
+ , boost::system::error_code(error::bad_descriptor))));
+ return;
+ }
+
+ if (m_bound_to == udp::endpoint())
+ {
+ post(m_io_service, make_malloc(std::bind(std::move(handler)
+ , boost::system::error_code(error::invalid_argument))));
+ return;
+ }
+
+ if (!m_incoming_queue.empty())
+ {
+ post(m_io_service, make_malloc(std::bind(std::move(handler), boost::system::error_code())));
+ return;
+ }
+
+ m_recv_null_buffers = true;
+ m_wait_recv_handler = std::move(handler);
+ m_recv_sender = sender;
+ }
+
+ void udp::socket::async_receive_from_impl(
+ std::vector<asio::mutable_buffer> const& bufs
+ , udp::endpoint* sender
+ , socket_base::message_flags /* flags */
+ , aux::function<void(boost::system::error_code const&
+ , std::size_t)> handler)
+ {
+ assert(!bufs.empty());
+
+ boost::system::error_code ec;
+ std::size_t bytes_transferred = receive_from_impl(bufs, sender, 0, ec);
+ if (ec == boost::system::error_code(error::would_block))
+ {
+ m_recv_buffer = bufs;
+ m_recv_handler = std::move(handler);
+ m_recv_sender = sender;
+ m_recv_null_buffers = false;
+
+ return;
+ }
+
+ if (ec)
+ {
+ post(m_io_service, make_malloc(std::bind(std::move(handler), ec, std::size_t(0))));
+ m_recv_handler = nullptr;
+ m_recv_buffer.clear();
+ m_recv_sender = nullptr;
+ m_recv_null_buffers = false;
+ return;
+ }
+
+ post(m_io_service, make_malloc(std::bind(std::move(handler), ec, bytes_transferred)));
+ m_recv_handler = nullptr;
+ m_recv_buffer.clear();
+ m_recv_sender = nullptr;
+ m_recv_null_buffers = false;
+ }
+
+ std::size_t udp::socket::send_to_impl(std::vector<asio::const_buffer> const& b
+ , udp::endpoint const& dst, message_flags /* flags */
+ , boost::system::error_code& ec)
+ {
+ assert(m_non_blocking && "blocking operations not supported");
+
+ if (m_bound_to == ip::udp::endpoint())
+ {
+ // the socket was not bound, bind to anything
+ bind(udp::endpoint(), ec);
+ if (ec) return 0;
+ }
+
+ ec.clear();
+ std::size_t ret = 0;
+ for (std::vector<asio::const_buffer>::const_iterator i = b.begin()
+ , end(b.end()); i != end; ++i)
+ {
+ ret += i->size();
+ }
+ if (ret == 0)
+ {
+ ec = boost::system::error_code(error::invalid_argument);
+ return 0;
+ }
+
+ time_point now = chrono::high_resolution_clock::now();
+
+ const int mtu = m_io_service.get_path_mtu(m_bound_to.address(), dst.address());
+
+ if (int(ret) > 65535)
+ {
+ ec = boost::system::error_code(error::message_size);
+ return 0;
+ }
+
+ if (m_dont_fragment && int(ret) > mtu)
+ {
+ // silently drop packet
+ ec.clear();
+ return ret;
+ }
+
+ // determine the bandwidth in terms of nanoseconds / byte
+ const double nanoseconds_per_byte = 1000000000.0
+ / double(aux::nic_bandwidth);
+
+ if (m_next_send - now > m_send_queue_time)
+ {
+ // our send queue is too large.
+ ec = boost::system::error_code(asio::error::would_block);
+ return 0;
+ }
+
+ route hops = m_io_service.find_udp_socket(*this, dst);
+ if (hops.empty())
+ {
+ // the packet is silently dropped
+ // TODO: it would be nice if this would result in a round-trip time
+ // with an ICMP host unreachable or connection_refused error
+ return ret;
+ }
+
+ hops.prepend(m_io_service.get_outgoing_route(m_bound_to.address()));
+
+ m_next_send = std::max(now, m_next_send);
+
+ aux::packet p;
+ p.overhead = 28;
+ p.type = aux::packet::type_t::payload;
+ p.from = m_bound_to;
+ p.hops = hops;
+ for (std::vector<asio::const_buffer>::const_iterator i = b.begin()
+ , end(b.end()); i != end; ++i)
+ {
+ p.buffer.insert(p.buffer.end(), static_cast<std::uint8_t const*>(i->data())
+ , static_cast<std::uint8_t const*>(i->data()) + i->size());
+ }
+
+ auto* log = m_io_service.sim().get_pcap();
+ if (log) log->log_udp(p, m_bound_to, dst);
+
+ int const packet_size = int(p.buffer.size() + p.overhead);
+ forward_packet(std::move(p));
+
+ m_next_send += chrono::duration_cast<duration>(chrono::nanoseconds(
+ boost::int64_t(nanoseconds_per_byte * packet_size)));
+
+ return ret;
+ }
+
+ void udp::socket::incoming_packet(aux::packet p)
+ {
+ int const packet_size = int(p.buffer.size() + p.overhead);
+
+ // silent drop. If the application isn't reading fast enough, drop packets
+ // TODO: make this limit controlled by SO_RECVBUF socket option
+ if (m_queue_size + packet_size > 256 * 1024) return;
+
+ m_queue_size += int(p.buffer.size());
+ m_incoming_queue.push_back(std::move(p));
+
+ maybe_wakeup_reader();
+ }
+
+ void udp::socket::maybe_wakeup_reader()
+ {
+ if (m_incoming_queue.size() != 1 || (!m_recv_handler && !m_wait_recv_handler)) return;
+
+ // there is an outstanding operation waiting for an incoming packet
+ if (m_recv_null_buffers)
+ {
+ async_wait_receive_impl(m_recv_sender, std::move(m_wait_recv_handler));
+ }
+ else
+ {
+ async_receive_from_impl(m_recv_buffer, m_recv_sender, 0, std::move(m_recv_handler));
+ }
+
+// m_recv_handler = nullptr;
+// m_recv_buffer.clear();
+// m_recv_sender = nullptr;
+ }
+
+} // ip
+} // asio
+} // sim
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include <functional>
+
+#include "catch.hpp"
+
+#ifdef __GNUC__
+// for CATCH's CHECK macro
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+using namespace sim::asio;
+using namespace sim::chrono;
+using sim::simulation;
+using sim::default_config;
+using namespace std::placeholders;
+
+namespace {
+char send_buffer[10000];
+char recv_buffer[10000];
+int num_received = 0;
+int num_sent = 0;
+
+void on_sent(boost::system::error_code const& ec, std::size_t bytes_transferred
+ , ip::tcp::socket& sock)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+ if (ec)
+ {
+ std::printf("[%4d] send error %s\n", millis, ec.message().c_str());
+ return;
+ }
+
+ num_sent += int(bytes_transferred);
+
+ std::printf("[%4d] sent %d bytes\n", millis, int(bytes_transferred));
+ std::printf("closing\n");
+ sock.close();
+}
+
+void on_receive(boost::system::error_code const& ec
+ , std::size_t bytes_transferred, ip::tcp::socket& sock)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+ if (ec)
+ {
+ std::printf("[%4d] receive error %s\n", millis, ec.message().c_str());
+ return;
+ }
+
+ num_received += int(bytes_transferred);
+
+ std::printf("[%4d] received %d bytes\n", millis, int(bytes_transferred));
+
+ sock.async_read_some(sim::asio::buffer(recv_buffer, sizeof(recv_buffer))
+ , std::bind(&on_receive, _1, _2, std::ref(sock)));
+}
+
+void incoming_connection(boost::system::error_code const& ec
+ , ip::tcp::socket& sock, ip::tcp::endpoint const& ep)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+ if (ec)
+ {
+ std::printf("[%4d] error while accepting connection: %s\n"
+ , millis, ec.message().c_str());
+ return;
+ }
+
+ boost::system::error_code err;
+ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
+ REQUIRE(!ec);
+ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
+ REQUIRE(!ec);
+ std::printf("[%4d] received incoming connection from: %s:%d. local endpoint: %s:%d\n"
+ , millis, ep.address().to_string().c_str(), ep.port()
+ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
+ CHECK(local_endpoint.port() == 1337);
+ CHECK(local_endpoint.address().to_string() == "40.30.20.10");
+ CHECK(remote_endpoint.port() != 0);
+ CHECK(remote_endpoint.address().to_string() == "10.20.30.40");
+
+ sock.async_read_some(sim::asio::buffer(recv_buffer, sizeof(recv_buffer))
+ , std::bind(&on_receive, _1, _2, std::ref(sock)));
+}
+
+void on_connected(boost::system::error_code const& ec
+ , ip::tcp::socket& sock)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+ if (ec)
+ {
+ std::printf("[%4d] error while connecting: %s\n", millis, ec.message().c_str());
+ return;
+ }
+
+ boost::system::error_code err;
+ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
+ REQUIRE(!ec);
+ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
+ REQUIRE(!ec);
+
+ std::printf("[%4d] made outgoing connection to: %s:%d. local endpoint: %s:%d\n"
+ , millis
+ , remote_endpoint.address().to_string().c_str(), remote_endpoint.port()
+ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
+
+ CHECK(remote_endpoint.port() == 1337);
+ CHECK(remote_endpoint.address().to_string() == "40.30.20.10");
+ CHECK(local_endpoint.port() != 0);
+ CHECK(local_endpoint.address().to_string() == "10.20.30.40");
+
+ std::printf("sending %d bytes\n", int(sizeof(send_buffer)));
+ sock.async_write_some(sim::asio::buffer(send_buffer, sizeof(send_buffer))
+ , std::bind(&on_sent, _1, _2, std::ref(sock)));
+}
+
+}
+
+TEST_CASE("accept incoming connection on acceptor socket", "[acceptor]")
+{
+ default_config cfg;
+ simulation sim(cfg);
+ io_context incoming_ios(sim, ip::make_address_v4("40.30.20.10"));
+ io_context outgoing_ios(sim, ip::make_address_v4("10.20.30.40"));
+ ip::tcp::acceptor listener(incoming_ios);
+
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+
+ boost::system::error_code ec;
+ listener.open(ip::tcp::v4(), ec);
+ REQUIRE(!ec);
+ listener.bind(ip::tcp::endpoint(ip::address(), 1337), ec);
+ REQUIRE(!ec);
+ listener.listen(10, ec);
+ REQUIRE(!ec);
+
+ ip::tcp::socket incoming(incoming_ios);
+ ip::tcp::endpoint remote_endpoint;
+ listener.async_accept(incoming, remote_endpoint
+ , std::bind(&incoming_connection, _1, std::ref(incoming)
+ , std::cref(remote_endpoint)));
+
+ dump_network_graph(sim, "accept.dot");
+
+ std::printf("[%4d] connecting\n", millis);
+ ip::tcp::socket outgoing(outgoing_ios);
+ outgoing.open(ip::tcp::v4(), ec);
+ REQUIRE(!ec);
+ outgoing.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
+ , 1337), std::bind(&on_connected, _1, std::ref(outgoing)));
+
+ sim.run();
+
+ millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+
+ CHECK(num_received == num_sent);
+ CHECK(num_received > 0);
+}
+
--- /dev/null
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+// Catch v3.6.0
+// Generated: 2024-05-05 20:53:27.071502
+// ----------------------------------------------------------
+// This file is an amalgamation of multiple different files.
+// You probably shouldn't edit it directly.
+// ----------------------------------------------------------
+#ifndef CATCH_AMALGAMATED_HPP_INCLUDED
+#define CATCH_AMALGAMATED_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2. It includes **all** of Catch2 headers.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header is added to either the top level folder, or to the
+ * corresponding internal subfolder, it should be added here. Headers
+ * added to the various subparts (e.g. matchers, generators, etc...),
+ * should go their respective catch-all headers.
+ */
+
+#ifndef CATCH_ALL_HPP_INCLUDED
+#define CATCH_ALL_HPP_INCLUDED
+
+
+
+/** \file
+ * This is a convenience header for Catch2's benchmarking. It includes
+ * **all** of Catch2 headers related to benchmarking.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header is added to either the `benchmark` folder, or to
+ * the corresponding internal (detail) subfolder, it should be added here.
+ */
+
+#ifndef CATCH_BENCHMARK_ALL_HPP_INCLUDED
+#define CATCH_BENCHMARK_ALL_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_BENCHMARK_HPP_INCLUDED
+#define CATCH_BENCHMARK_HPP_INCLUDED
+
+
+
+#ifndef CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+#define CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+// Detect a number of compiler features - by compiler
+// The following features are defined:
+//
+// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
+// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
+// ****************
+// Note to maintainers: if new toggles are added please document them
+// in configuration.md, too
+// ****************
+
+// In general each macro has a _NO_<feature name> form
+// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
+// Many features, at point of detection, define an _INTERNAL_ macro, so they
+// can be combined, en-mass, with the _NO_ forms later.
+
+
+
+#ifndef CATCH_PLATFORM_HPP_INCLUDED
+#define CATCH_PLATFORM_HPP_INCLUDED
+
+// See e.g.:
+// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
+#ifdef __APPLE__
+# ifndef __has_extension
+# define __has_extension(x) 0
+# endif
+# include <TargetConditionals.h>
+# if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
+ (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
+# define CATCH_PLATFORM_MAC
+# elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
+# define CATCH_PLATFORM_IPHONE
+# endif
+
+#elif defined(linux) || defined(__linux) || defined(__linux__)
+# define CATCH_PLATFORM_LINUX
+
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
+# define CATCH_PLATFORM_WINDOWS
+
+# if defined( WINAPI_FAMILY ) && ( WINAPI_FAMILY == WINAPI_FAMILY_APP )
+# define CATCH_PLATFORM_WINDOWS_UWP
+# endif
+
+#elif defined(__ORBIS__) || defined(__PROSPERO__)
+# define CATCH_PLATFORM_PLAYSTATION
+
+#endif
+
+#endif // CATCH_PLATFORM_HPP_INCLUDED
+
+#ifdef __cplusplus
+
+# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+# define CATCH_CPP17_OR_GREATER
+# endif
+
+# if (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
+# define CATCH_CPP20_OR_GREATER
+# endif
+
+#endif
+
+// Only GCC compiler should be used in this block, so other compilers trying to
+// mask themselves as GCC should be ignored.
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) && !defined(__NVCOMPILER)
+# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
+# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" )
+
+// This only works on GCC 9+. so we have to also add a global suppression of Wparentheses
+// for older versions of GCC.
+# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+ _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" )
+
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+ _Pragma( "GCC diagnostic ignored \"-Wunused-result\"" )
+
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ _Pragma( "GCC diagnostic ignored \"-Wunused-variable\"" )
+
+# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+ _Pragma( "GCC diagnostic ignored \"-Wuseless-cast\"" )
+
+# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+ _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
+
+# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#endif
+
+#if defined(__NVCOMPILER)
+# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "diag push" )
+# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "diag pop" )
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress declared_but_not_referenced" )
+#endif
+
+#if defined(__CUDACC__) && !defined(__clang__)
+# ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+// New pragmas introduced in CUDA 11.5+
+# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic push" )
+# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic pop" )
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "nv_diag_suppress 177" )
+# else
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress 177" )
+# endif
+#endif
+
+// clang-cl defines _MSC_VER as well as __clang__, which could cause the
+// start/stop internal suppression macros to be double defined.
+#if defined(__clang__) && !defined(_MSC_VER)
+
+# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
+# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic pop" )
+
+#endif // __clang__ && !_MSC_VER
+
+#if defined(__clang__)
+
+// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
+// which results in calls to destructors being emitted for each temporary,
+// without a matching initialization. In practice, this can result in something
+// like `std::string::~string` being called on an uninitialized value.
+//
+// For example, this code will likely segfault under IBM XL:
+// ```
+// REQUIRE(std::string("12") + "34" == "1234")
+// ```
+//
+// Similarly, NVHPC's implementation of `__builtin_constant_p` has a bug which
+// results in calls to the immediately evaluated lambda expressions to be
+// reported as unevaluated lambdas.
+// https://developer.nvidia.com/nvidia_bug/3321845.
+//
+// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
+# if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
+# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
+# endif
+
+
+# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+ _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+
+# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+ _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+
+# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+ _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+ _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+
+# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+ _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
+
+# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+ _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
+
+#endif // __clang__
+
+
+////////////////////////////////////////////////////////////////////////////////
+// We know some environments not to support full POSIX signals
+#if defined( CATCH_PLATFORM_WINDOWS ) || \
+ defined( CATCH_PLATFORM_PLAYSTATION ) || \
+ defined( __CYGWIN__ ) || \
+ defined( __QNX__ ) || \
+ defined( __EMSCRIPTEN__ ) || \
+ defined( __DJGPP__ ) || \
+ defined( __OS400__ )
+# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+#else
+# define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Assume that some platforms do not support getenv.
+#if defined( CATCH_PLATFORM_WINDOWS_UWP ) || \
+ defined( CATCH_PLATFORM_PLAYSTATION ) || \
+ defined( _GAMING_XBOX )
+# define CATCH_INTERNAL_CONFIG_NO_GETENV
+#else
+# define CATCH_INTERNAL_CONFIG_GETENV
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Android somehow still does not support std::to_string
+#if defined(__ANDROID__)
+# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Not all Windows environments support SEH properly
+#if defined(__MINGW32__)
+# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// PS4
+#if defined(__ORBIS__)
+# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Cygwin
+#ifdef __CYGWIN__
+
+// Required for some versions of Cygwin to declare gettimeofday
+// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
+# define _BSD_SOURCE
+// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
+# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
+ && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+
+# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+
+# endif
+#endif // __CYGWIN__
+
+////////////////////////////////////////////////////////////////////////////////
+// Visual C++
+#if defined(_MSC_VER)
+
+// We want to defer to nvcc-specific warning suppression if we are compiled
+// with nvcc masquerading for MSVC.
+# if !defined( __CUDACC__ )
+# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ __pragma( warning( push ) )
+# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ __pragma( warning( pop ) )
+# endif
+
+// Universal Windows platform does not support SEH
+// Or console colours (or console at all...)
+# if defined(CATCH_PLATFORM_WINDOWS_UWP)
+# define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
+# else
+# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+# endif
+
+// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
+// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
+// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
+# if !defined(__clang__) // Handle Clang masquerading for msvc
+# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+# endif // MSVC_TRADITIONAL
+# endif // __clang__
+
+#endif // _MSC_VER
+
+#if defined(_REENTRANT) || defined(_MSC_VER)
+// Enable async processing, as -pthread is specified or no additional linking is required
+# define CATCH_INTERNAL_CONFIG_USE_ASYNC
+#endif // _MSC_VER
+
+////////////////////////////////////////////////////////////////////////////////
+// Check if we are compiled with -fno-exceptions or equivalent
+#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
+# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
+#endif
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Embarcadero C++Build
+#if defined(__BORLANDC__)
+ #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// RTX is a special version of Windows that is real time.
+// This means that it is detected as Windows, but does not provide
+// the same set of capabilities as real Windows does.
+#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
+ #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+ #define CATCH_INTERNAL_CONFIG_NO_ASYNC
+ #define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
+#endif
+
+#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
+#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Various stdlib support checks that require __has_include
+#if defined(__has_include)
+ // Check if string_view is available and usable
+ #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+ # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+ #endif
+
+ // Check if optional is available and usable
+ # if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+ # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+ # endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+
+ // Check if byte is available and usable
+ # if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+ # include <cstddef>
+ # if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)
+ # define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+ # endif
+ # endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+
+ // Check if variant is available and usable
+ # if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+ # if defined(__clang__) && (__clang_major__ < 8)
+ // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+ // fix should be in clang 8, workaround in libstdc++ 8.2
+ # include <ciso646>
+ # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+ # define CATCH_CONFIG_NO_CPP17_VARIANT
+ # else
+ # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+ # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+ # else
+ # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+ # endif // defined(__clang__) && (__clang_major__ < 8)
+ # endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // defined(__has_include)
+
+
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
+# define CATCH_CONFIG_WINDOWS_SEH
+#endif
+// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
+#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
+# define CATCH_CONFIG_POSIX_SIGNALS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_GETENV) && !defined(CATCH_INTERNAL_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_GETENV)
+# define CATCH_CONFIG_GETENV
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
+# define CATCH_CONFIG_CPP11_TO_STRING
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+# define CATCH_CONFIG_CPP17_OPTIONAL
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
+# define CATCH_CONFIG_CPP17_STRING_VIEW
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
+# define CATCH_CONFIG_CPP17_VARIANT
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
+# define CATCH_CONFIG_CPP17_BYTE
+#endif
+
+
+#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
+# define CATCH_CONFIG_NEW_CAPTURE
+#endif
+
+#if !defined( CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED ) && \
+ !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS ) && \
+ !defined( CATCH_CONFIG_NO_DISABLE_EXCEPTIONS )
+# define CATCH_CONFIG_DISABLE_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+# define CATCH_CONFIG_POLYFILL_ISNAN
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+# define CATCH_CONFIG_USE_ASYNC
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+# define CATCH_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+
+// Even if we do not think the compiler has that warning, we still have
+// to provide a macro that can be used by the code.
+#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
+# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
+# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
+# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
+# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT)
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS)
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS)
+# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
+# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+#endif
+#if !defined( CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS )
+# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+#if !defined( CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS )
+# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS
+#endif
+#if !defined( CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS )
+# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
+#endif
+
+
+// The goal of this macro is to avoid evaluation of the arguments, but
+// still have the compiler warn on problems inside...
+#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
+# define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
+#endif
+
+#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
+# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#elif defined(__clang__) && (__clang_major__ < 5)
+# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#define CATCH_TRY if ((true))
+#define CATCH_CATCH_ALL if ((false))
+#define CATCH_CATCH_ANON(type) if ((false))
+#else
+#define CATCH_TRY try
+#define CATCH_CATCH_ALL catch (...)
+#define CATCH_CATCH_ANON(type) catch (type)
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
+#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#endif
+
+#if defined( CATCH_PLATFORM_WINDOWS ) && \
+ !defined( CATCH_CONFIG_COLOUR_WIN32 ) && \
+ !defined( CATCH_CONFIG_NO_COLOUR_WIN32 ) && \
+ !defined( CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32 )
+# define CATCH_CONFIG_COLOUR_WIN32
+#endif
+
+#if defined( CATCH_CONFIG_SHARED_LIBRARY ) && defined( _MSC_VER ) && \
+ !defined( CATCH_CONFIG_STATIC )
+# ifdef Catch2_EXPORTS
+# define CATCH_EXPORT //__declspec( dllexport ) // not needed
+# else
+# define CATCH_EXPORT __declspec( dllimport )
+# endif
+#else
+# define CATCH_EXPORT
+#endif
+
+#endif // CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+
+
+#ifndef CATCH_CONTEXT_HPP_INCLUDED
+#define CATCH_CONTEXT_HPP_INCLUDED
+
+
+namespace Catch {
+
+ class IResultCapture;
+ class IConfig;
+
+ class Context {
+ IConfig const* m_config = nullptr;
+ IResultCapture* m_resultCapture = nullptr;
+
+ CATCH_EXPORT static Context* currentContext;
+ friend Context& getCurrentMutableContext();
+ friend Context const& getCurrentContext();
+ static void createContext();
+ friend void cleanUpContext();
+
+ public:
+ IResultCapture* getResultCapture() const { return m_resultCapture; }
+ IConfig const* getConfig() const { return m_config; }
+ void setResultCapture( IResultCapture* resultCapture );
+ void setConfig( IConfig const* config );
+ };
+
+ Context& getCurrentMutableContext();
+
+ inline Context const& getCurrentContext() {
+ // We duplicate the logic from `getCurrentMutableContext` here,
+ // to avoid paying the call overhead in debug mode.
+ if ( !Context::currentContext ) { Context::createContext(); }
+ // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+ return *Context::currentContext;
+ }
+
+ void cleanUpContext();
+
+ class SimplePcg32;
+ SimplePcg32& sharedRng();
+}
+
+#endif // CATCH_CONTEXT_HPP_INCLUDED
+
+
+#ifndef CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+#define CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+
+#include <type_traits>
+
+//! Replacement for std::move with better compile time performance
+#define CATCH_MOVE(...) static_cast<std::remove_reference_t<decltype(__VA_ARGS__)>&&>(__VA_ARGS__)
+
+//! Replacement for std::forward with better compile time performance
+#define CATCH_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
+
+#endif // CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+#define CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+
+namespace Catch {
+
+ //! Used to signal that an assertion macro failed
+ struct TestFailureException{};
+ //! Used to signal that the remainder of a test should be skipped
+ struct TestSkipException {};
+
+ /**
+ * Outlines throwing of `TestFailureException` into a single TU
+ *
+ * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
+ */
+ [[noreturn]] void throw_test_failure_exception();
+
+ /**
+ * Outlines throwing of `TestSkipException` into a single TU
+ *
+ * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
+ */
+ [[noreturn]] void throw_test_skip_exception();
+
+} // namespace Catch
+
+#endif // CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_UNIQUE_NAME_HPP_INCLUDED
+#define CATCH_UNIQUE_NAME_HPP_INCLUDED
+
+
+
+
+/** \file
+ * Wrapper for the CONFIG configuration option
+ *
+ * When generating internal unique names, there are two options. Either
+ * we mix in the current line number, or mix in an incrementing number.
+ * We prefer the latter, using `__COUNTER__`, but users might want to
+ * use the former.
+ */
+
+#ifndef CATCH_CONFIG_COUNTER_HPP_INCLUDED
+#define CATCH_CONFIG_COUNTER_HPP_INCLUDED
+
+
+#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
+ #define CATCH_INTERNAL_CONFIG_COUNTER
+#endif
+
+#if defined( CATCH_INTERNAL_CONFIG_COUNTER ) && \
+ !defined( CATCH_CONFIG_NO_COUNTER ) && \
+ !defined( CATCH_CONFIG_COUNTER )
+# define CATCH_CONFIG_COUNTER
+#endif
+
+
+#endif // CATCH_CONFIG_COUNTER_HPP_INCLUDED
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+#ifdef CATCH_CONFIG_COUNTER
+# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
+#else
+# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+#endif
+
+#endif // CATCH_UNIQUE_NAME_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+#define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+
+#include <string>
+#include <chrono>
+
+
+
+#ifndef CATCH_STRINGREF_HPP_INCLUDED
+#define CATCH_STRINGREF_HPP_INCLUDED
+
+#include <cstddef>
+#include <string>
+#include <iosfwd>
+#include <cassert>
+
+#include <cstring>
+
+namespace Catch {
+
+ /// A non-owning string class (similar to the forthcoming std::string_view)
+ /// Note that, because a StringRef may be a substring of another string,
+ /// it may not be null terminated.
+ class StringRef {
+ public:
+ using size_type = std::size_t;
+ using const_iterator = const char*;
+
+ static constexpr size_type npos{ static_cast<size_type>( -1 ) };
+
+ private:
+ static constexpr char const* const s_empty = "";
+
+ char const* m_start = s_empty;
+ size_type m_size = 0;
+
+ public: // construction
+ constexpr StringRef() noexcept = default;
+
+ StringRef( char const* rawChars ) noexcept;
+
+ constexpr StringRef( char const* rawChars, size_type size ) noexcept
+ : m_start( rawChars ),
+ m_size( size )
+ {}
+
+ StringRef( std::string const& stdString ) noexcept
+ : m_start( stdString.c_str() ),
+ m_size( stdString.size() )
+ {}
+
+ explicit operator std::string() const {
+ return std::string(m_start, m_size);
+ }
+
+ public: // operators
+ auto operator == ( StringRef other ) const noexcept -> bool {
+ return m_size == other.m_size
+ && (std::memcmp( m_start, other.m_start, m_size ) == 0);
+ }
+ auto operator != (StringRef other) const noexcept -> bool {
+ return !(*this == other);
+ }
+
+ constexpr auto operator[] ( size_type index ) const noexcept -> char {
+ assert(index < m_size);
+ return m_start[index];
+ }
+
+ bool operator<(StringRef rhs) const noexcept;
+
+ public: // named queries
+ constexpr auto empty() const noexcept -> bool {
+ return m_size == 0;
+ }
+ constexpr auto size() const noexcept -> size_type {
+ return m_size;
+ }
+
+ // Returns a substring of [start, start + length).
+ // If start + length > size(), then the substring is [start, size()).
+ // If start > size(), then the substring is empty.
+ constexpr StringRef substr(size_type start, size_type length) const noexcept {
+ if (start < m_size) {
+ const auto shortened_size = m_size - start;
+ return StringRef(m_start + start, (shortened_size < length) ? shortened_size : length);
+ } else {
+ return StringRef();
+ }
+ }
+
+ // Returns the current start pointer. May not be null-terminated.
+ constexpr char const* data() const noexcept {
+ return m_start;
+ }
+
+ constexpr const_iterator begin() const { return m_start; }
+ constexpr const_iterator end() const { return m_start + m_size; }
+
+
+ friend std::string& operator += (std::string& lhs, StringRef rhs);
+ friend std::ostream& operator << (std::ostream& os, StringRef str);
+ friend std::string operator+(StringRef lhs, StringRef rhs);
+
+ /**
+ * Provides a three-way comparison with rhs
+ *
+ * Returns negative number if lhs < rhs, 0 if lhs == rhs, and a positive
+ * number if lhs > rhs
+ */
+ int compare( StringRef rhs ) const;
+ };
+
+
+ constexpr auto operator ""_sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
+ return StringRef( rawChars, size );
+ }
+} // namespace Catch
+
+constexpr auto operator ""_catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
+ return Catch::StringRef( rawChars, size );
+}
+
+#endif // CATCH_STRINGREF_HPP_INCLUDED
+
+
+#ifndef CATCH_RESULT_TYPE_HPP_INCLUDED
+#define CATCH_RESULT_TYPE_HPP_INCLUDED
+
+namespace Catch {
+
+ // ResultWas::OfType enum
+ struct ResultWas { enum OfType {
+ Unknown = -1,
+ Ok = 0,
+ Info = 1,
+ Warning = 2,
+ // TODO: Should explicit skip be considered "not OK" (cf. isOk)? I.e., should it have the failure bit?
+ ExplicitSkip = 4,
+
+ FailureBit = 0x10,
+
+ ExpressionFailed = FailureBit | 1,
+ ExplicitFailure = FailureBit | 2,
+
+ Exception = 0x100 | FailureBit,
+
+ ThrewException = Exception | 1,
+ DidntThrowException = Exception | 2,
+
+ FatalErrorCondition = 0x200 | FailureBit
+
+ }; };
+
+ bool isOk( ResultWas::OfType resultType );
+ bool isJustInfo( int flags );
+
+
+ // ResultDisposition::Flags enum
+ struct ResultDisposition { enum Flags {
+ Normal = 0x01,
+
+ ContinueOnFailure = 0x02, // Failures fail test, but execution continues
+ FalseTest = 0x04, // Prefix expression with !
+ SuppressFail = 0x08 // Failures are reported but do not fail the test
+ }; };
+
+ ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
+
+ bool shouldContinueOnFailure( int flags );
+ inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
+ bool shouldSuppressFailure( int flags );
+
+} // end namespace Catch
+
+#endif // CATCH_RESULT_TYPE_HPP_INCLUDED
+
+
+#ifndef CATCH_UNIQUE_PTR_HPP_INCLUDED
+#define CATCH_UNIQUE_PTR_HPP_INCLUDED
+
+#include <cassert>
+#include <type_traits>
+
+
+namespace Catch {
+namespace Detail {
+ /**
+ * A reimplementation of `std::unique_ptr` for improved compilation performance
+ *
+ * Does not support arrays nor custom deleters.
+ */
+ template <typename T>
+ class unique_ptr {
+ T* m_ptr;
+ public:
+ constexpr unique_ptr(std::nullptr_t = nullptr):
+ m_ptr{}
+ {}
+ explicit constexpr unique_ptr(T* ptr):
+ m_ptr(ptr)
+ {}
+
+ template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+ unique_ptr(unique_ptr<U>&& from):
+ m_ptr(from.release())
+ {}
+
+ template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+ unique_ptr& operator=(unique_ptr<U>&& from) {
+ reset(from.release());
+
+ return *this;
+ }
+
+ unique_ptr(unique_ptr const&) = delete;
+ unique_ptr& operator=(unique_ptr const&) = delete;
+
+ unique_ptr(unique_ptr&& rhs) noexcept:
+ m_ptr(rhs.m_ptr) {
+ rhs.m_ptr = nullptr;
+ }
+ unique_ptr& operator=(unique_ptr&& rhs) noexcept {
+ reset(rhs.release());
+
+ return *this;
+ }
+
+ ~unique_ptr() {
+ delete m_ptr;
+ }
+
+ T& operator*() {
+ assert(m_ptr);
+ return *m_ptr;
+ }
+ T const& operator*() const {
+ assert(m_ptr);
+ return *m_ptr;
+ }
+ T* operator->() noexcept {
+ assert(m_ptr);
+ return m_ptr;
+ }
+ T const* operator->() const noexcept {
+ assert(m_ptr);
+ return m_ptr;
+ }
+
+ T* get() { return m_ptr; }
+ T const* get() const { return m_ptr; }
+
+ void reset(T* ptr = nullptr) {
+ delete m_ptr;
+ m_ptr = ptr;
+ }
+
+ T* release() {
+ auto temp = m_ptr;
+ m_ptr = nullptr;
+ return temp;
+ }
+
+ explicit operator bool() const {
+ return m_ptr;
+ }
+
+ friend void swap(unique_ptr& lhs, unique_ptr& rhs) {
+ auto temp = lhs.m_ptr;
+ lhs.m_ptr = rhs.m_ptr;
+ rhs.m_ptr = temp;
+ }
+ };
+
+ //! Specialization to cause compile-time error for arrays
+ template <typename T>
+ class unique_ptr<T[]>;
+
+ template <typename T, typename... Args>
+ unique_ptr<T> make_unique(Args&&... args) {
+ return unique_ptr<T>(new T(CATCH_FORWARD(args)...));
+ }
+
+
+} // end namespace Detail
+} // end namespace Catch
+
+#endif // CATCH_UNIQUE_PTR_HPP_INCLUDED
+
+
+#ifndef CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
+#define CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CLOCK_HPP_INCLUDED
+#define CATCH_CLOCK_HPP_INCLUDED
+
+#include <chrono>
+
+namespace Catch {
+ namespace Benchmark {
+ using IDuration = std::chrono::nanoseconds;
+ using FDuration = std::chrono::duration<double, std::nano>;
+
+ template <typename Clock>
+ using TimePoint = typename Clock::time_point;
+
+ using default_clock = std::chrono::steady_clock;
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CLOCK_HPP_INCLUDED
+
+namespace Catch {
+
+ // We cannot forward declare the type with default template argument
+ // multiple times, so it is split out into a separate header so that
+ // we can prevent multiple declarations in dependees
+ template <typename Duration = Benchmark::FDuration>
+ struct BenchmarkStats;
+
+} // end namespace Catch
+
+#endif // CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
+
+namespace Catch {
+
+ class AssertionResult;
+ struct AssertionInfo;
+ struct SectionInfo;
+ struct SectionEndInfo;
+ struct MessageInfo;
+ struct MessageBuilder;
+ struct Counts;
+ struct AssertionReaction;
+ struct SourceLineInfo;
+
+ class ITransientExpression;
+ class IGeneratorTracker;
+
+ struct BenchmarkInfo;
+
+ namespace Generators {
+ class GeneratorUntypedBase;
+ using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
+ }
+
+
+ class IResultCapture {
+ public:
+ virtual ~IResultCapture();
+
+ virtual void notifyAssertionStarted( AssertionInfo const& info ) = 0;
+ virtual bool sectionStarted( StringRef sectionName,
+ SourceLineInfo const& sectionLineInfo,
+ Counts& assertions ) = 0;
+ virtual void sectionEnded( SectionEndInfo&& endInfo ) = 0;
+ virtual void sectionEndedEarly( SectionEndInfo&& endInfo ) = 0;
+
+ virtual IGeneratorTracker*
+ acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo ) = 0;
+ virtual IGeneratorTracker*
+ createGeneratorTracker( StringRef generatorName,
+ SourceLineInfo lineInfo,
+ Generators::GeneratorBasePtr&& generator ) = 0;
+
+ virtual void benchmarkPreparing( StringRef name ) = 0;
+ virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
+ virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+ virtual void benchmarkFailed( StringRef error ) = 0;
+
+ virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+ virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+ virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0;
+
+ virtual void handleFatalErrorCondition( StringRef message ) = 0;
+
+ virtual void handleExpr
+ ( AssertionInfo const& info,
+ ITransientExpression const& expr,
+ AssertionReaction& reaction ) = 0;
+ virtual void handleMessage
+ ( AssertionInfo const& info,
+ ResultWas::OfType resultType,
+ StringRef message,
+ AssertionReaction& reaction ) = 0;
+ virtual void handleUnexpectedExceptionNotThrown
+ ( AssertionInfo const& info,
+ AssertionReaction& reaction ) = 0;
+ virtual void handleUnexpectedInflightException
+ ( AssertionInfo const& info,
+ std::string&& message,
+ AssertionReaction& reaction ) = 0;
+ virtual void handleIncomplete
+ ( AssertionInfo const& info ) = 0;
+ virtual void handleNonExpr
+ ( AssertionInfo const &info,
+ ResultWas::OfType resultType,
+ AssertionReaction &reaction ) = 0;
+
+
+
+ virtual bool lastAssertionPassed() = 0;
+ virtual void assertionPassed() = 0;
+
+ // Deprecated, do not use:
+ virtual std::string getCurrentTestName() const = 0;
+ virtual const AssertionResult* getLastResult() const = 0;
+ virtual void exceptionEarlyReported() = 0;
+ };
+
+ IResultCapture& getResultCapture();
+}
+
+#endif // CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+#define CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+
+
+
+#ifndef CATCH_NONCOPYABLE_HPP_INCLUDED
+#define CATCH_NONCOPYABLE_HPP_INCLUDED
+
+namespace Catch {
+ namespace Detail {
+
+ //! Deriving classes become noncopyable and nonmovable
+ class NonCopyable {
+ NonCopyable( NonCopyable const& ) = delete;
+ NonCopyable( NonCopyable&& ) = delete;
+ NonCopyable& operator=( NonCopyable const& ) = delete;
+ NonCopyable& operator=( NonCopyable&& ) = delete;
+
+ protected:
+ NonCopyable() noexcept = default;
+ };
+
+ } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_NONCOPYABLE_HPP_INCLUDED
+
+#include <chrono>
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+ enum class Verbosity {
+ Quiet = 0,
+ Normal,
+ High
+ };
+
+ struct WarnAbout { enum What {
+ Nothing = 0x00,
+ //! A test case or leaf section did not run any assertions
+ NoAssertions = 0x01,
+ //! A command line test spec matched no test cases
+ UnmatchedTestSpec = 0x02,
+ }; };
+
+ enum class ShowDurations {
+ DefaultForReporter,
+ Always,
+ Never
+ };
+ enum class TestRunOrder {
+ Declared,
+ LexicographicallySorted,
+ Randomized
+ };
+ enum class ColourMode : std::uint8_t {
+ //! Let Catch2 pick implementation based on platform detection
+ PlatformDefault,
+ //! Use ANSI colour code escapes
+ ANSI,
+ //! Use Win32 console colour API
+ Win32,
+ //! Don't use any colour
+ None
+ };
+ struct WaitForKeypress { enum When {
+ Never,
+ BeforeStart = 1,
+ BeforeExit = 2,
+ BeforeStartAndExit = BeforeStart | BeforeExit
+ }; };
+
+ class TestSpec;
+ class IStream;
+
+ class IConfig : public Detail::NonCopyable {
+ public:
+ virtual ~IConfig();
+
+ virtual bool allowThrows() const = 0;
+ virtual StringRef name() const = 0;
+ virtual bool includeSuccessfulResults() const = 0;
+ virtual bool shouldDebugBreak() const = 0;
+ virtual bool warnAboutMissingAssertions() const = 0;
+ virtual bool warnAboutUnmatchedTestSpecs() const = 0;
+ virtual bool zeroTestsCountAsSuccess() const = 0;
+ virtual int abortAfter() const = 0;
+ virtual bool showInvisibles() const = 0;
+ virtual ShowDurations showDurations() const = 0;
+ virtual double minDuration() const = 0;
+ virtual TestSpec const& testSpec() const = 0;
+ virtual bool hasTestFilters() const = 0;
+ virtual std::vector<std::string> const& getTestsOrTags() const = 0;
+ virtual TestRunOrder runOrder() const = 0;
+ virtual uint32_t rngSeed() const = 0;
+ virtual unsigned int shardCount() const = 0;
+ virtual unsigned int shardIndex() const = 0;
+ virtual ColourMode defaultColourMode() const = 0;
+ virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+ virtual Verbosity verbosity() const = 0;
+
+ virtual bool skipBenchmarks() const = 0;
+ virtual bool benchmarkNoAnalysis() const = 0;
+ virtual unsigned int benchmarkSamples() const = 0;
+ virtual double benchmarkConfidenceInterval() const = 0;
+ virtual unsigned int benchmarkResamples() const = 0;
+ virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
+ };
+}
+
+#endif // CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+#define CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+ class TestCaseHandle;
+ struct TestCaseInfo;
+ class ITestCaseRegistry;
+ class IExceptionTranslatorRegistry;
+ class IExceptionTranslator;
+ class ReporterRegistry;
+ class IReporterFactory;
+ class ITagAliasRegistry;
+ class ITestInvoker;
+ class IMutableEnumValuesRegistry;
+ struct SourceLineInfo;
+
+ class StartupExceptionRegistry;
+ class EventListenerFactory;
+
+ using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+
+ class IRegistryHub {
+ public:
+ virtual ~IRegistryHub(); // = default
+
+ virtual ReporterRegistry const& getReporterRegistry() const = 0;
+ virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+ virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+ virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
+
+
+ virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
+ };
+
+ class IMutableRegistryHub {
+ public:
+ virtual ~IMutableRegistryHub(); // = default
+ virtual void registerReporter( std::string const& name, IReporterFactoryPtr factory ) = 0;
+ virtual void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) = 0;
+ virtual void registerTest(Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker) = 0;
+ virtual void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) = 0;
+ virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+ virtual void registerStartupException() noexcept = 0;
+ virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
+ };
+
+ IRegistryHub const& getRegistryHub();
+ IMutableRegistryHub& getMutableRegistryHub();
+ void cleanUp();
+ std::string translateActiveException();
+
+}
+
+#endif // CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+
+
+#ifndef CATCH_BENCHMARK_STATS_HPP_INCLUDED
+#define CATCH_BENCHMARK_STATS_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ESTIMATE_HPP_INCLUDED
+#define CATCH_ESTIMATE_HPP_INCLUDED
+
+namespace Catch {
+ namespace Benchmark {
+ template <typename Type>
+ struct Estimate {
+ Type point;
+ Type lower_bound;
+ Type upper_bound;
+ double confidence_interval;
+ };
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ESTIMATE_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
+#define CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
+
+namespace Catch {
+ namespace Benchmark {
+ struct OutlierClassification {
+ int samples_seen = 0;
+ int low_severe = 0; // more than 3 times IQR below Q1
+ int low_mild = 0; // 1.5 to 3 times IQR below Q1
+ int high_mild = 0; // 1.5 to 3 times IQR above Q3
+ int high_severe = 0; // more than 3 times IQR above Q3
+
+ int total() const {
+ return low_severe + low_mild + high_mild + high_severe;
+ }
+ };
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_OUTLIERS_CLASSIFICATION_HPP_INCLUDED
+// The fwd decl & default specialization needs to be seen by VS2017 before
+// BenchmarkStats itself, or VS2017 will report compilation error.
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+ struct BenchmarkInfo {
+ std::string name;
+ double estimatedDuration;
+ int iterations;
+ unsigned int samples;
+ unsigned int resamples;
+ double clockResolution;
+ double clockCost;
+ };
+
+ // We need to keep template parameter for backwards compatibility,
+ // but we also do not want to use the template paraneter.
+ template <class Dummy>
+ struct BenchmarkStats {
+ BenchmarkInfo info;
+
+ std::vector<Benchmark::FDuration> samples;
+ Benchmark::Estimate<Benchmark::FDuration> mean;
+ Benchmark::Estimate<Benchmark::FDuration> standardDeviation;
+ Benchmark::OutlierClassification outliers;
+ double outlierVariance;
+ };
+
+
+} // end namespace Catch
+
+#endif // CATCH_BENCHMARK_STATS_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ENVIRONMENT_HPP_INCLUDED
+#define CATCH_ENVIRONMENT_HPP_INCLUDED
+
+
+namespace Catch {
+ namespace Benchmark {
+ struct EnvironmentEstimate {
+ FDuration mean;
+ OutlierClassification outliers;
+ };
+ struct Environment {
+ EnvironmentEstimate clock_resolution;
+ EnvironmentEstimate clock_cost;
+ };
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ENVIRONMENT_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_EXECUTION_PLAN_HPP_INCLUDED
+#define CATCH_EXECUTION_PLAN_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+#define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CHRONOMETER_HPP_INCLUDED
+#define CATCH_CHRONOMETER_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_OPTIMIZER_HPP_INCLUDED
+#define CATCH_OPTIMIZER_HPP_INCLUDED
+
+#if defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
+# include <atomic> // atomic_thread_fence
+#endif
+
+
+#include <type_traits>
+
+namespace Catch {
+ namespace Benchmark {
+#if defined(__GNUC__) || defined(__clang__)
+ template <typename T>
+ inline void keep_memory(T* p) {
+ asm volatile("" : : "g"(p) : "memory");
+ }
+ inline void keep_memory() {
+ asm volatile("" : : : "memory");
+ }
+
+ namespace Detail {
+ inline void optimizer_barrier() { keep_memory(); }
+ } // namespace Detail
+#elif defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
+
+#if defined(_MSVC_VER)
+#pragma optimize("", off)
+#elif defined(__IAR_SYSTEMS_ICC__)
+// For IAR the pragma only affects the following function
+#pragma optimize=disable
+#endif
+ template <typename T>
+ inline void keep_memory(T* p) {
+ // thanks @milleniumbug
+ *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
+ }
+ // TODO equivalent keep_memory()
+#if defined(_MSVC_VER)
+#pragma optimize("", on)
+#endif
+
+ namespace Detail {
+ inline void optimizer_barrier() {
+ std::atomic_thread_fence(std::memory_order_seq_cst);
+ }
+ } // namespace Detail
+
+#endif
+
+ template <typename T>
+ inline void deoptimize_value(T&& x) {
+ keep_memory(&x);
+ }
+
+ template <typename Fn, typename... Args>
+ inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<!std::is_same<void, decltype(fn(args...))>::value> {
+ deoptimize_value(CATCH_FORWARD(fn) (CATCH_FORWARD(args)...));
+ }
+
+ template <typename Fn, typename... Args>
+ inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<std::is_same<void, decltype(fn(args...))>::value> {
+ CATCH_FORWARD((fn)) (CATCH_FORWARD(args)...);
+ }
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_OPTIMIZER_HPP_INCLUDED
+
+
+#ifndef CATCH_META_HPP_INCLUDED
+#define CATCH_META_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+ template <typename>
+ struct true_given : std::true_type {};
+
+ struct is_callable_tester {
+ template <typename Fun, typename... Args>
+ static true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
+ template <typename...>
+ static std::false_type test(...);
+ };
+
+ template <typename T>
+ struct is_callable;
+
+ template <typename Fun, typename... Args>
+ struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+
+
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+ // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+ // replaced with std::invoke_result here.
+ template <typename Func, typename... U>
+ using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
+#else
+ template <typename Func, typename... U>
+ using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::result_of_t<Func(U...)>>>;
+#endif
+
+} // namespace Catch
+
+namespace mpl_{
+ struct na;
+}
+
+#endif // CATCH_META_HPP_INCLUDED
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ struct ChronometerConcept {
+ virtual void start() = 0;
+ virtual void finish() = 0;
+ virtual ~ChronometerConcept(); // = default;
+
+ ChronometerConcept() = default;
+ ChronometerConcept(ChronometerConcept const&) = default;
+ ChronometerConcept& operator=(ChronometerConcept const&) = default;
+ };
+ template <typename Clock>
+ struct ChronometerModel final : public ChronometerConcept {
+ void start() override { started = Clock::now(); }
+ void finish() override { finished = Clock::now(); }
+
+ IDuration elapsed() const {
+ return std::chrono::duration_cast<std::chrono::nanoseconds>(
+ finished - started );
+ }
+
+ TimePoint<Clock> started;
+ TimePoint<Clock> finished;
+ };
+ } // namespace Detail
+
+ struct Chronometer {
+ public:
+ template <typename Fun>
+ void measure(Fun&& fun) { measure(CATCH_FORWARD(fun), is_callable<Fun(int)>()); }
+
+ int runs() const { return repeats; }
+
+ Chronometer(Detail::ChronometerConcept& meter, int repeats_)
+ : impl(&meter)
+ , repeats(repeats_) {}
+
+ private:
+ template <typename Fun>
+ void measure(Fun&& fun, std::false_type) {
+ measure([&fun](int) { return fun(); }, std::true_type());
+ }
+
+ template <typename Fun>
+ void measure(Fun&& fun, std::true_type) {
+ Detail::optimizer_barrier();
+ impl->start();
+ for (int i = 0; i < repeats; ++i) invoke_deoptimized(fun, i);
+ impl->finish();
+ Detail::optimizer_barrier();
+ }
+
+ Detail::ChronometerConcept* impl;
+ int repeats;
+ };
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CHRONOMETER_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ template <typename T, typename U>
+ struct is_related
+ : std::is_same<std::decay_t<T>, std::decay_t<U>> {};
+
+ /// We need to reinvent std::function because every piece of code that might add overhead
+ /// in a measurement context needs to have consistent performance characteristics so that we
+ /// can account for it in the measurement.
+ /// Implementations of std::function with optimizations that aren't always applicable, like
+ /// small buffer optimizations, are not uncommon.
+ /// This is effectively an implementation of std::function without any such optimizations;
+ /// it may be slow, but it is consistently slow.
+ struct BenchmarkFunction {
+ private:
+ struct callable {
+ virtual void call(Chronometer meter) const = 0;
+ virtual Catch::Detail::unique_ptr<callable> clone() const = 0;
+ virtual ~callable(); // = default;
+
+ callable() = default;
+ callable(callable const&) = default;
+ callable& operator=(callable const&) = default;
+ };
+ template <typename Fun>
+ struct model : public callable {
+ model(Fun&& fun_) : fun(CATCH_MOVE(fun_)) {}
+ model(Fun const& fun_) : fun(fun_) {}
+
+ Catch::Detail::unique_ptr<callable> clone() const override {
+ return Catch::Detail::make_unique<model<Fun>>( *this );
+ }
+
+ void call(Chronometer meter) const override {
+ call(meter, is_callable<Fun(Chronometer)>());
+ }
+ void call(Chronometer meter, std::true_type) const {
+ fun(meter);
+ }
+ void call(Chronometer meter, std::false_type) const {
+ meter.measure(fun);
+ }
+
+ Fun fun;
+ };
+
+ struct do_nothing { void operator()() const {} };
+
+ template <typename T>
+ BenchmarkFunction(model<T>* c) : f(c) {}
+
+ public:
+ BenchmarkFunction()
+ : f(new model<do_nothing>{ {} }) {}
+
+ template <typename Fun,
+ std::enable_if_t<!is_related<Fun, BenchmarkFunction>::value, int> = 0>
+ BenchmarkFunction(Fun&& fun)
+ : f(new model<std::decay_t<Fun>>(CATCH_FORWARD(fun))) {}
+
+ BenchmarkFunction( BenchmarkFunction&& that ) noexcept:
+ f( CATCH_MOVE( that.f ) ) {}
+
+ BenchmarkFunction(BenchmarkFunction const& that)
+ : f(that.f->clone()) {}
+
+ BenchmarkFunction&
+ operator=( BenchmarkFunction&& that ) noexcept {
+ f = CATCH_MOVE( that.f );
+ return *this;
+ }
+
+ BenchmarkFunction& operator=(BenchmarkFunction const& that) {
+ f = that.f->clone();
+ return *this;
+ }
+
+ void operator()(Chronometer meter) const { f->call(meter); }
+
+ private:
+ Catch::Detail::unique_ptr<callable> f;
+ };
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_REPEAT_HPP_INCLUDED
+#define CATCH_REPEAT_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ template <typename Fun>
+ struct repeater {
+ void operator()(int k) const {
+ for (int i = 0; i < k; ++i) {
+ fun();
+ }
+ }
+ Fun fun;
+ };
+ template <typename Fun>
+ repeater<std::decay_t<Fun>> repeat(Fun&& fun) {
+ return { CATCH_FORWARD(fun) };
+ }
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_REPEAT_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+#define CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_MEASURE_HPP_INCLUDED
+#define CATCH_MEASURE_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+#define CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ template <typename T>
+ struct CompleteType { using type = T; };
+ template <>
+ struct CompleteType<void> { struct type {}; };
+
+ template <typename T>
+ using CompleteType_t = typename CompleteType<T>::type;
+
+ template <typename Result>
+ struct CompleteInvoker {
+ template <typename Fun, typename... Args>
+ static Result invoke(Fun&& fun, Args&&... args) {
+ return CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
+ }
+ };
+ template <>
+ struct CompleteInvoker<void> {
+ template <typename Fun, typename... Args>
+ static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
+ CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
+ return {};
+ }
+ };
+
+ // invoke and not return void :(
+ template <typename Fun, typename... Args>
+ CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
+ return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
+ }
+
+ } // namespace Detail
+
+ template <typename Fun>
+ Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
+ return Detail::complete_invoke(CATCH_FORWARD(fun));
+ }
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_TIMING_HPP_INCLUDED
+#define CATCH_TIMING_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+ namespace Benchmark {
+ template <typename Result>
+ struct Timing {
+ IDuration elapsed;
+ Result result;
+ int iterations;
+ };
+ template <typename Func, typename... Args>
+ using TimingOf = Timing<Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_TIMING_HPP_INCLUDED
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ template <typename Clock, typename Fun, typename... Args>
+ TimingOf<Fun, Args...> measure(Fun&& fun, Args&&... args) {
+ auto start = Clock::now();
+ auto&& r = Detail::complete_invoke(fun, CATCH_FORWARD(args)...);
+ auto end = Clock::now();
+ auto delta = end - start;
+ return { delta, CATCH_FORWARD(r), 1 };
+ }
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_MEASURE_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ template <typename Clock, typename Fun>
+ TimingOf<Fun, int> measure_one(Fun&& fun, int iters, std::false_type) {
+ return Detail::measure<Clock>(fun, iters);
+ }
+ template <typename Clock, typename Fun>
+ TimingOf<Fun, Chronometer> measure_one(Fun&& fun, int iters, std::true_type) {
+ Detail::ChronometerModel<Clock> meter;
+ auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
+
+ return { meter.elapsed(), CATCH_MOVE(result), iters };
+ }
+
+ template <typename Clock, typename Fun>
+ using run_for_at_least_argument_t = std::conditional_t<is_callable<Fun(Chronometer)>::value, Chronometer, int>;
+
+
+ [[noreturn]]
+ void throw_optimized_away_error();
+
+ template <typename Clock, typename Fun>
+ TimingOf<Fun, run_for_at_least_argument_t<Clock, Fun>>
+ run_for_at_least(IDuration how_long,
+ const int initial_iterations,
+ Fun&& fun) {
+ auto iters = initial_iterations;
+ while (iters < (1 << 30)) {
+ auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
+
+ if (Timing.elapsed >= how_long) {
+ return { Timing.elapsed, CATCH_MOVE(Timing.result), iters };
+ }
+ iters *= 2;
+ }
+ throw_optimized_away_error();
+ }
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+ namespace Benchmark {
+ struct ExecutionPlan {
+ int iterations_per_sample;
+ FDuration estimated_duration;
+ Detail::BenchmarkFunction benchmark;
+ FDuration warmup_time;
+ int warmup_iterations;
+
+ template <typename Clock>
+ std::vector<FDuration> run(const IConfig &cfg, Environment env) const {
+ // warmup a bit
+ Detail::run_for_at_least<Clock>(
+ std::chrono::duration_cast<IDuration>( warmup_time ),
+ warmup_iterations,
+ Detail::repeat( []() { return Clock::now(); } )
+ );
+
+ std::vector<FDuration> times;
+ const auto num_samples = cfg.benchmarkSamples();
+ times.reserve( num_samples );
+ for ( size_t i = 0; i < num_samples; ++i ) {
+ Detail::ChronometerModel<Clock> model;
+ this->benchmark( Chronometer( model, iterations_per_sample ) );
+ auto sample_time = model.elapsed() - env.clock_cost.mean;
+ if ( sample_time < FDuration::zero() ) {
+ sample_time = FDuration::zero();
+ }
+ times.push_back(sample_time / iterations_per_sample);
+ }
+ return times;
+ }
+ };
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_EXECUTION_PLAN_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+#define CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_STATS_HPP_INCLUDED
+#define CATCH_STATS_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ using sample = std::vector<double>;
+
+ double weighted_average_quantile( int k,
+ int q,
+ double* first,
+ double* last );
+
+ OutlierClassification
+ classify_outliers( double const* first, double const* last );
+
+ double mean( double const* first, double const* last );
+
+ double normal_cdf( double x );
+
+ double erfc_inv(double x);
+
+ double normal_quantile(double p);
+
+ Estimate<double>
+ bootstrap( double confidence_level,
+ double* first,
+ double* last,
+ sample const& resample,
+ double ( *estimator )( double const*, double const* ) );
+
+ struct bootstrap_analysis {
+ Estimate<double> mean;
+ Estimate<double> standard_deviation;
+ double outlier_variance;
+ };
+
+ bootstrap_analysis analyse_samples(double confidence_level,
+ unsigned int n_resamples,
+ double* first,
+ double* last);
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_STATS_HPP_INCLUDED
+
+#include <algorithm>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ template <typename Clock>
+ std::vector<double> resolution(int k) {
+ std::vector<TimePoint<Clock>> times;
+ times.reserve(static_cast<size_t>(k + 1));
+ for ( int i = 0; i < k + 1; ++i ) {
+ times.push_back( Clock::now() );
+ }
+
+ std::vector<double> deltas;
+ deltas.reserve(static_cast<size_t>(k));
+ for ( size_t idx = 1; idx < times.size(); ++idx ) {
+ deltas.push_back( static_cast<double>(
+ ( times[idx] - times[idx - 1] ).count() ) );
+ }
+
+ return deltas;
+ }
+
+ constexpr auto warmup_iterations = 10000;
+ constexpr auto warmup_time = std::chrono::milliseconds(100);
+ constexpr auto minimum_ticks = 1000;
+ constexpr auto warmup_seed = 10000;
+ constexpr auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+ constexpr auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+ constexpr auto clock_cost_estimation_tick_limit = 100000;
+ constexpr auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+ constexpr auto clock_cost_estimation_iterations = 10000;
+
+ template <typename Clock>
+ int warmup() {
+ return run_for_at_least<Clock>(warmup_time, warmup_seed, &resolution<Clock>)
+ .iterations;
+ }
+ template <typename Clock>
+ EnvironmentEstimate estimate_clock_resolution(int iterations) {
+ auto r = run_for_at_least<Clock>(clock_resolution_estimation_time, iterations, &resolution<Clock>)
+ .result;
+ return {
+ FDuration(mean(r.data(), r.data() + r.size())),
+ classify_outliers(r.data(), r.data() + r.size()),
+ };
+ }
+ template <typename Clock>
+ EnvironmentEstimate estimate_clock_cost(FDuration resolution) {
+ auto time_limit = (std::min)(
+ resolution * clock_cost_estimation_tick_limit,
+ FDuration(clock_cost_estimation_time_limit));
+ auto time_clock = [](int k) {
+ return Detail::measure<Clock>([k] {
+ for (int i = 0; i < k; ++i) {
+ volatile auto ignored = Clock::now();
+ (void)ignored;
+ }
+ }).elapsed;
+ };
+ time_clock(1);
+ int iters = clock_cost_estimation_iterations;
+ auto&& r = run_for_at_least<Clock>(clock_cost_estimation_time, iters, time_clock);
+ std::vector<double> times;
+ int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+ times.reserve(static_cast<size_t>(nsamples));
+ for ( int s = 0; s < nsamples; ++s ) {
+ times.push_back( static_cast<double>(
+ ( time_clock( r.iterations ) / r.iterations )
+ .count() ) );
+ }
+ return {
+ FDuration(mean(times.data(), times.data() + times.size())),
+ classify_outliers(times.data(), times.data() + times.size()),
+ };
+ }
+
+ template <typename Clock>
+ Environment measure_environment() {
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+ static Catch::Detail::unique_ptr<Environment> env;
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+ if (env) {
+ return *env;
+ }
+
+ auto iters = Detail::warmup<Clock>();
+ auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+ auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
+
+ env = Catch::Detail::make_unique<Environment>( Environment{resolution, cost} );
+ return *env;
+ }
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_ANALYSE_HPP_INCLUDED
+#define CATCH_ANALYSE_HPP_INCLUDED
+
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+#define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+ namespace Benchmark {
+ struct SampleAnalysis {
+ std::vector<FDuration> samples;
+ Estimate<FDuration> mean;
+ Estimate<FDuration> standard_deviation;
+ OutlierClassification outliers;
+ double outlier_variance;
+ };
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+
+
+namespace Catch {
+ class IConfig;
+
+ namespace Benchmark {
+ namespace Detail {
+ SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last);
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_ANALYSE_HPP_INCLUDED
+
+#include <algorithm>
+#include <chrono>
+#include <exception>
+#include <string>
+#include <cmath>
+
+namespace Catch {
+ namespace Benchmark {
+ struct Benchmark {
+ Benchmark(std::string&& benchmarkName)
+ : name(CATCH_MOVE(benchmarkName)) {}
+
+ template <class FUN>
+ Benchmark(std::string&& benchmarkName , FUN &&func)
+ : fun(CATCH_MOVE(func)), name(CATCH_MOVE(benchmarkName)) {}
+
+ template <typename Clock>
+ ExecutionPlan prepare(const IConfig &cfg, Environment env) const {
+ auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+ auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
+ auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<IDuration>(run_time), 1, fun);
+ int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+ return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+ }
+
+ template <typename Clock = default_clock>
+ void run() {
+ static_assert( Clock::is_steady,
+ "Benchmarking clock should be steady" );
+ auto const* cfg = getCurrentContext().getConfig();
+
+ auto env = Detail::measure_environment<Clock>();
+
+ getResultCapture().benchmarkPreparing(name);
+ CATCH_TRY{
+ auto plan = user_code([&] {
+ return prepare<Clock>(*cfg, env);
+ });
+
+ BenchmarkInfo info {
+ CATCH_MOVE(name),
+ plan.estimated_duration.count(),
+ plan.iterations_per_sample,
+ cfg->benchmarkSamples(),
+ cfg->benchmarkResamples(),
+ env.clock_resolution.mean.count(),
+ env.clock_cost.mean.count()
+ };
+
+ getResultCapture().benchmarkStarting(info);
+
+ auto samples = user_code([&] {
+ return plan.template run<Clock>(*cfg, env);
+ });
+
+ auto analysis = Detail::analyse(*cfg, samples.data(), samples.data() + samples.size());
+ BenchmarkStats<> stats{ CATCH_MOVE(info), CATCH_MOVE(analysis.samples), analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+ getResultCapture().benchmarkEnded(stats);
+ } CATCH_CATCH_ANON (TestFailureException const&) {
+ getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr);
+ } CATCH_CATCH_ALL{
+ getResultCapture().benchmarkFailed(translateActiveException());
+ // We let the exception go further up so that the
+ // test case is marked as failed.
+ std::rethrow_exception(std::current_exception());
+ }
+ }
+
+ // sets lambda to be used in fun *and* executes benchmark!
+ template <typename Fun, std::enable_if_t<!Detail::is_related<Fun, Benchmark>::value, int> = 0>
+ Benchmark & operator=(Fun func) {
+ auto const* cfg = getCurrentContext().getConfig();
+ if (!cfg->skipBenchmarks()) {
+ fun = Detail::BenchmarkFunction(func);
+ run();
+ }
+ return *this;
+ }
+
+ explicit operator bool() {
+ return true;
+ }
+
+ private:
+ Detail::BenchmarkFunction fun;
+ std::string name;
+ };
+ }
+} // namespace Catch
+
+#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
+#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
+
+#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
+ if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+ BenchmarkName = [&](int benchmarkIndex)
+
+#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
+ if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+ BenchmarkName = [&]
+
+#if defined(CATCH_CONFIG_PREFIX_ALL)
+
+#define CATCH_BENCHMARK(...) \
+ INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define CATCH_BENCHMARK_ADVANCED(name) \
+ INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
+
+#else
+
+#define BENCHMARK(...) \
+ INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define BENCHMARK_ADVANCED(name) \
+ INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
+
+#endif
+
+#endif // CATCH_BENCHMARK_HPP_INCLUDED
+
+
+// Adapted from donated nonius code.
+
+#ifndef CATCH_CONSTRUCTOR_HPP_INCLUDED
+#define CATCH_CONSTRUCTOR_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ template <typename T, bool Destruct>
+ struct ObjectStorage
+ {
+ ObjectStorage() = default;
+
+ ObjectStorage(const ObjectStorage& other)
+ {
+ new(&data) T(other.stored_object());
+ }
+
+ ObjectStorage(ObjectStorage&& other)
+ {
+ new(data) T(CATCH_MOVE(other.stored_object()));
+ }
+
+ ~ObjectStorage() { destruct_on_exit<T>(); }
+
+ template <typename... Args>
+ void construct(Args&&... args)
+ {
+ new (data) T(CATCH_FORWARD(args)...);
+ }
+
+ template <bool AllowManualDestruction = !Destruct>
+ std::enable_if_t<AllowManualDestruction> destruct()
+ {
+ stored_object().~T();
+ }
+
+ private:
+ // If this is a constructor benchmark, destruct the underlying object
+ template <typename U>
+ void destruct_on_exit(std::enable_if_t<Destruct, U>* = nullptr) { destruct<true>(); }
+ // Otherwise, don't
+ template <typename U>
+ void destruct_on_exit(std::enable_if_t<!Destruct, U>* = nullptr) { }
+
+#if defined( __GNUC__ ) && __GNUC__ <= 6
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+ T& stored_object() { return *reinterpret_cast<T*>( data ); }
+
+ T const& stored_object() const {
+ return *reinterpret_cast<T const*>( data );
+ }
+#if defined( __GNUC__ ) && __GNUC__ <= 6
+# pragma GCC diagnostic pop
+#endif
+
+ alignas( T ) unsigned char data[sizeof( T )]{};
+ };
+ } // namespace Detail
+
+ template <typename T>
+ using storage_for = Detail::ObjectStorage<T, true>;
+
+ template <typename T>
+ using destructable_object = Detail::ObjectStorage<T, false>;
+ } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CONSTRUCTOR_HPP_INCLUDED
+
+#endif // CATCH_BENCHMARK_ALL_HPP_INCLUDED
+
+
+#ifndef CATCH_APPROX_HPP_INCLUDED
+#define CATCH_APPROX_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TOSTRING_HPP_INCLUDED
+#define CATCH_TOSTRING_HPP_INCLUDED
+
+
+#include <vector>
+#include <cstddef>
+#include <type_traits>
+#include <string>
+
+
+
+
+/** \file
+ * Wrapper for the WCHAR configuration option
+ *
+ * We want to support platforms that do not provide `wchar_t`, so we
+ * sometimes have to disable providing wchar_t overloads through Catch2,
+ * e.g. the StringMaker specialization for `std::wstring`.
+ */
+
+#ifndef CATCH_CONFIG_WCHAR_HPP_INCLUDED
+#define CATCH_CONFIG_WCHAR_HPP_INCLUDED
+
+
+// We assume that WCHAR should be enabled by default, and only disabled
+// for a shortlist (so far only DJGPP) of compilers.
+
+#if defined(__DJGPP__)
+# define CATCH_INTERNAL_CONFIG_NO_WCHAR
+#endif // __DJGPP__
+
+#if !defined( CATCH_INTERNAL_CONFIG_NO_WCHAR ) && \
+ !defined( CATCH_CONFIG_NO_WCHAR ) && \
+ !defined( CATCH_CONFIG_WCHAR )
+# define CATCH_CONFIG_WCHAR
+#endif
+
+#endif // CATCH_CONFIG_WCHAR_HPP_INCLUDED
+
+
+#ifndef CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+#define CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+#include <string>
+
+namespace Catch {
+
+ class ReusableStringStream : Detail::NonCopyable {
+ std::size_t m_index;
+ std::ostream* m_oss;
+ public:
+ ReusableStringStream();
+ ~ReusableStringStream();
+
+ //! Returns the serialized state
+ std::string str() const;
+ //! Sets internal state to `str`
+ void str(std::string const& str);
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+// Old versions of GCC do not understand -Wnonnull-compare
+#pragma GCC diagnostic ignored "-Wpragmas"
+// Streaming a function pointer triggers Waddress and Wnonnull-compare
+// on GCC, because it implicitly converts it to bool and then decides
+// that the check it uses (a? true : false) is tautological and cannot
+// be null...
+#pragma GCC diagnostic ignored "-Waddress"
+#pragma GCC diagnostic ignored "-Wnonnull-compare"
+#endif
+
+ template<typename T>
+ auto operator << ( T const& value ) -> ReusableStringStream& {
+ *m_oss << value;
+ return *this;
+ }
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+ auto get() -> std::ostream& { return *m_oss; }
+ };
+}
+
+#endif // CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+
+
+#ifndef CATCH_VOID_TYPE_HPP_INCLUDED
+#define CATCH_VOID_TYPE_HPP_INCLUDED
+
+
+namespace Catch {
+ namespace Detail {
+
+ template <typename...>
+ struct make_void { using type = void; };
+
+ template <typename... Ts>
+ using void_t = typename make_void<Ts...>::type;
+
+ } // namespace Detail
+} // namespace Catch
+
+
+#endif // CATCH_VOID_TYPE_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+#define CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+
+ namespace Detail {
+ struct EnumInfo {
+ StringRef m_name;
+ std::vector<std::pair<int, StringRef>> m_values;
+
+ ~EnumInfo();
+
+ StringRef lookup( int value ) const;
+ };
+ } // namespace Detail
+
+ class IMutableEnumValuesRegistry {
+ public:
+ virtual ~IMutableEnumValuesRegistry(); // = default;
+
+ virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+
+ template<typename E>
+ Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+ static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
+ std::vector<int> intValues;
+ intValues.reserve( values.size() );
+ for( auto enumValue : values )
+ intValues.push_back( static_cast<int>( enumValue ) );
+ return registerEnum( enumName, allEnums, intValues );
+ }
+ };
+
+} // Catch
+
+#endif // CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+#include <string_view>
+#endif
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
+#endif
+
+// We need a dummy global operator<< so we can bring it into Catch namespace later
+struct Catch_global_namespace_dummy{};
+std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
+
+namespace Catch {
+ // Bring in global namespace operator<< for ADL lookup in
+ // `IsStreamInsertable` below.
+ using ::operator<<;
+
+ namespace Detail {
+
+ inline std::size_t catch_strnlen(const char *str, std::size_t n) {
+ auto ret = std::char_traits<char>::find(str, n, '\0');
+ if (ret != nullptr) {
+ return static_cast<std::size_t>(ret - str);
+ }
+ return n;
+ }
+
+ constexpr StringRef unprintableString = "{?}"_sr;
+
+ //! Encases `string in quotes, and optionally escapes invisibles
+ std::string convertIntoString( StringRef string, bool escapeInvisibles );
+
+ //! Encases `string` in quotes, and escapes invisibles if user requested
+ //! it via CLI
+ std::string convertIntoString( StringRef string );
+
+ std::string rawMemoryToString( const void *object, std::size_t size );
+
+ template<typename T>
+ std::string rawMemoryToString( const T& object ) {
+ return rawMemoryToString( &object, sizeof(object) );
+ }
+
+ template<typename T>
+ class IsStreamInsertable {
+ template<typename Stream, typename U>
+ static auto test(int)
+ -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
+
+ template<typename, typename>
+ static auto test(...)->std::false_type;
+
+ public:
+ static const bool value = decltype(test<std::ostream, const T&>(0))::value;
+ };
+
+ template<typename E>
+ std::string convertUnknownEnumToString( E e );
+
+ template<typename T>
+ std::enable_if_t<
+ !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+ std::string> convertUnstreamable( T const& ) {
+ return std::string(Detail::unprintableString);
+ }
+ template<typename T>
+ std::enable_if_t<
+ !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+ std::string> convertUnstreamable(T const& ex) {
+ return ex.what();
+ }
+
+
+ template<typename T>
+ std::enable_if_t<
+ std::is_enum<T>::value,
+ std::string> convertUnstreamable( T const& value ) {
+ return convertUnknownEnumToString( value );
+ }
+
+#if defined(_MANAGED)
+ //! Convert a CLR string to a utf8 std::string
+ template<typename T>
+ std::string clrReferenceToString( T^ ref ) {
+ if (ref == nullptr)
+ return std::string("null");
+ auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
+ cli::pin_ptr<System::Byte> p = &bytes[0];
+ return std::string(reinterpret_cast<char const *>(p), bytes->Length);
+ }
+#endif
+
+ } // namespace Detail
+
+
+ template <typename T, typename = void>
+ struct StringMaker {
+ template <typename Fake = T>
+ static
+ std::enable_if_t<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
+ convert(const Fake& value) {
+ ReusableStringStream rss;
+ // NB: call using the function-like syntax to avoid ambiguity with
+ // user-defined templated operator<< under clang.
+ rss.operator<<(value);
+ return rss.str();
+ }
+
+ template <typename Fake = T>
+ static
+ std::enable_if_t<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
+ convert( const Fake& value ) {
+#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
+ return Detail::convertUnstreamable(value);
+#else
+ return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
+#endif
+ }
+ };
+
+ namespace Detail {
+
+ // This function dispatches all stringification requests inside of Catch.
+ // Should be preferably called fully qualified, like ::Catch::Detail::stringify
+ template <typename T>
+ std::string stringify(const T& e) {
+ return ::Catch::StringMaker<std::remove_cv_t<std::remove_reference_t<T>>>::convert(e);
+ }
+
+ template<typename E>
+ std::string convertUnknownEnumToString( E e ) {
+ return ::Catch::Detail::stringify(static_cast<std::underlying_type_t<E>>(e));
+ }
+
+#if defined(_MANAGED)
+ template <typename T>
+ std::string stringify( T^ e ) {
+ return ::Catch::StringMaker<T^>::convert(e);
+ }
+#endif
+
+ } // namespace Detail
+
+ // Some predefined specializations
+
+ template<>
+ struct StringMaker<std::string> {
+ static std::string convert(const std::string& str);
+ };
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+ template<>
+ struct StringMaker<std::string_view> {
+ static std::string convert(std::string_view str);
+ };
+#endif
+
+ template<>
+ struct StringMaker<char const *> {
+ static std::string convert(char const * str);
+ };
+ template<>
+ struct StringMaker<char *> {
+ static std::string convert(char * str);
+ };
+
+#if defined(CATCH_CONFIG_WCHAR)
+ template<>
+ struct StringMaker<std::wstring> {
+ static std::string convert(const std::wstring& wstr);
+ };
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+ template<>
+ struct StringMaker<std::wstring_view> {
+ static std::string convert(std::wstring_view str);
+ };
+# endif
+
+ template<>
+ struct StringMaker<wchar_t const *> {
+ static std::string convert(wchar_t const * str);
+ };
+ template<>
+ struct StringMaker<wchar_t *> {
+ static std::string convert(wchar_t * str);
+ };
+#endif // CATCH_CONFIG_WCHAR
+
+ template<size_t SZ>
+ struct StringMaker<char[SZ]> {
+ static std::string convert(char const* str) {
+ return Detail::convertIntoString(
+ StringRef( str, Detail::catch_strnlen( str, SZ ) ) );
+ }
+ };
+ template<size_t SZ>
+ struct StringMaker<signed char[SZ]> {
+ static std::string convert(signed char const* str) {
+ auto reinterpreted = reinterpret_cast<char const*>(str);
+ return Detail::convertIntoString(
+ StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
+ }
+ };
+ template<size_t SZ>
+ struct StringMaker<unsigned char[SZ]> {
+ static std::string convert(unsigned char const* str) {
+ auto reinterpreted = reinterpret_cast<char const*>(str);
+ return Detail::convertIntoString(
+ StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
+ }
+ };
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+ template<>
+ struct StringMaker<std::byte> {
+ static std::string convert(std::byte value);
+ };
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+ template<>
+ struct StringMaker<int> {
+ static std::string convert(int value);
+ };
+ template<>
+ struct StringMaker<long> {
+ static std::string convert(long value);
+ };
+ template<>
+ struct StringMaker<long long> {
+ static std::string convert(long long value);
+ };
+ template<>
+ struct StringMaker<unsigned int> {
+ static std::string convert(unsigned int value);
+ };
+ template<>
+ struct StringMaker<unsigned long> {
+ static std::string convert(unsigned long value);
+ };
+ template<>
+ struct StringMaker<unsigned long long> {
+ static std::string convert(unsigned long long value);
+ };
+
+ template<>
+ struct StringMaker<bool> {
+ static std::string convert(bool b) {
+ using namespace std::string_literals;
+ return b ? "true"s : "false"s;
+ }
+ };
+
+ template<>
+ struct StringMaker<char> {
+ static std::string convert(char c);
+ };
+ template<>
+ struct StringMaker<signed char> {
+ static std::string convert(signed char value);
+ };
+ template<>
+ struct StringMaker<unsigned char> {
+ static std::string convert(unsigned char value);
+ };
+
+ template<>
+ struct StringMaker<std::nullptr_t> {
+ static std::string convert(std::nullptr_t) {
+ using namespace std::string_literals;
+ return "nullptr"s;
+ }
+ };
+
+ template<>
+ struct StringMaker<float> {
+ static std::string convert(float value);
+ CATCH_EXPORT static int precision;
+ };
+
+ template<>
+ struct StringMaker<double> {
+ static std::string convert(double value);
+ CATCH_EXPORT static int precision;
+ };
+
+ template <typename T>
+ struct StringMaker<T*> {
+ template <typename U>
+ static std::string convert(U* p) {
+ if (p) {
+ return ::Catch::Detail::rawMemoryToString(p);
+ } else {
+ return "nullptr";
+ }
+ }
+ };
+
+ template <typename R, typename C>
+ struct StringMaker<R C::*> {
+ static std::string convert(R C::* p) {
+ if (p) {
+ return ::Catch::Detail::rawMemoryToString(p);
+ } else {
+ return "nullptr";
+ }
+ }
+ };
+
+#if defined(_MANAGED)
+ template <typename T>
+ struct StringMaker<T^> {
+ static std::string convert( T^ ref ) {
+ return ::Catch::Detail::clrReferenceToString(ref);
+ }
+ };
+#endif
+
+ namespace Detail {
+ template<typename InputIterator, typename Sentinel = InputIterator>
+ std::string rangeToString(InputIterator first, Sentinel last) {
+ ReusableStringStream rss;
+ rss << "{ ";
+ if (first != last) {
+ rss << ::Catch::Detail::stringify(*first);
+ for (++first; first != last; ++first)
+ rss << ", " << ::Catch::Detail::stringify(*first);
+ }
+ rss << " }";
+ return rss.str();
+ }
+ }
+
+} // namespace Catch
+
+//////////////////////////////////////////////////////
+// Separate std-lib types stringification, so it can be selectively enabled
+// This means that we do not bring in their headers
+
+#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
+# define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+# define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+# define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+# define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+#endif
+
+// Separate std::pair specialization
+#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
+#include <utility>
+namespace Catch {
+ template<typename T1, typename T2>
+ struct StringMaker<std::pair<T1, T2> > {
+ static std::string convert(const std::pair<T1, T2>& pair) {
+ ReusableStringStream rss;
+ rss << "{ "
+ << ::Catch::Detail::stringify(pair.first)
+ << ", "
+ << ::Catch::Detail::stringify(pair.second)
+ << " }";
+ return rss.str();
+ }
+ };
+}
+#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#include <optional>
+namespace Catch {
+ template<typename T>
+ struct StringMaker<std::optional<T> > {
+ static std::string convert(const std::optional<T>& optional) {
+ if (optional.has_value()) {
+ return ::Catch::Detail::stringify(*optional);
+ } else {
+ return "{ }";
+ }
+ }
+ };
+ template <>
+ struct StringMaker<std::nullopt_t> {
+ static std::string convert(const std::nullopt_t&) {
+ return "{ }";
+ }
+ };
+}
+#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+
+// Separate std::tuple specialization
+#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
+#include <tuple>
+namespace Catch {
+ namespace Detail {
+ template<
+ typename Tuple,
+ std::size_t N = 0,
+ bool = (N < std::tuple_size<Tuple>::value)
+ >
+ struct TupleElementPrinter {
+ static void print(const Tuple& tuple, std::ostream& os) {
+ os << (N ? ", " : " ")
+ << ::Catch::Detail::stringify(std::get<N>(tuple));
+ TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
+ }
+ };
+
+ template<
+ typename Tuple,
+ std::size_t N
+ >
+ struct TupleElementPrinter<Tuple, N, false> {
+ static void print(const Tuple&, std::ostream&) {}
+ };
+
+ }
+
+
+ template<typename ...Types>
+ struct StringMaker<std::tuple<Types...>> {
+ static std::string convert(const std::tuple<Types...>& tuple) {
+ ReusableStringStream rss;
+ rss << '{';
+ Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
+ rss << " }";
+ return rss.str();
+ }
+ };
+}
+#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
+#include <variant>
+namespace Catch {
+ template<>
+ struct StringMaker<std::monostate> {
+ static std::string convert(const std::monostate&) {
+ return "{ }";
+ }
+ };
+
+ template<typename... Elements>
+ struct StringMaker<std::variant<Elements...>> {
+ static std::string convert(const std::variant<Elements...>& variant) {
+ if (variant.valueless_by_exception()) {
+ return "{valueless variant}";
+ } else {
+ return std::visit(
+ [](const auto& value) {
+ return ::Catch::Detail::stringify(value);
+ },
+ variant
+ );
+ }
+ }
+ };
+}
+#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+
+namespace Catch {
+ // Import begin/ end from std here
+ using std::begin;
+ using std::end;
+
+ namespace Detail {
+ template <typename T, typename = void>
+ struct is_range_impl : std::false_type {};
+
+ template <typename T>
+ struct is_range_impl<T, void_t<decltype(begin(std::declval<T>()))>> : std::true_type {};
+ } // namespace Detail
+
+ template <typename T>
+ struct is_range : Detail::is_range_impl<T> {};
+
+#if defined(_MANAGED) // Managed types are never ranges
+ template <typename T>
+ struct is_range<T^> {
+ static const bool value = false;
+ };
+#endif
+
+ template<typename Range>
+ std::string rangeToString( Range const& range ) {
+ return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
+ }
+
+ // Handle vector<bool> specially
+ template<typename Allocator>
+ std::string rangeToString( std::vector<bool, Allocator> const& v ) {
+ ReusableStringStream rss;
+ rss << "{ ";
+ bool first = true;
+ for( bool b : v ) {
+ if( first )
+ first = false;
+ else
+ rss << ", ";
+ rss << ::Catch::Detail::stringify( b );
+ }
+ rss << " }";
+ return rss.str();
+ }
+
+ template<typename R>
+ struct StringMaker<R, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>> {
+ static std::string convert( R const& range ) {
+ return rangeToString( range );
+ }
+ };
+
+ template <typename T, size_t SZ>
+ struct StringMaker<T[SZ]> {
+ static std::string convert(T const(&arr)[SZ]) {
+ return rangeToString(arr);
+ }
+ };
+
+
+} // namespace Catch
+
+// Separate std::chrono::duration specialization
+#include <ctime>
+#include <ratio>
+#include <chrono>
+
+
+namespace Catch {
+
+template <class Ratio>
+struct ratio_string {
+ static std::string symbol() {
+ Catch::ReusableStringStream rss;
+ rss << '[' << Ratio::num << '/'
+ << Ratio::den << ']';
+ return rss.str();
+ }
+};
+
+template <>
+struct ratio_string<std::atto> {
+ static char symbol() { return 'a'; }
+};
+template <>
+struct ratio_string<std::femto> {
+ static char symbol() { return 'f'; }
+};
+template <>
+struct ratio_string<std::pico> {
+ static char symbol() { return 'p'; }
+};
+template <>
+struct ratio_string<std::nano> {
+ static char symbol() { return 'n'; }
+};
+template <>
+struct ratio_string<std::micro> {
+ static char symbol() { return 'u'; }
+};
+template <>
+struct ratio_string<std::milli> {
+ static char symbol() { return 'm'; }
+};
+
+ ////////////
+ // std::chrono::duration specializations
+ template<typename Value, typename Ratio>
+ struct StringMaker<std::chrono::duration<Value, Ratio>> {
+ static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
+ ReusableStringStream rss;
+ rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
+ return rss.str();
+ }
+ };
+ template<typename Value>
+ struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
+ static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
+ ReusableStringStream rss;
+ rss << duration.count() << " s";
+ return rss.str();
+ }
+ };
+ template<typename Value>
+ struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
+ static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
+ ReusableStringStream rss;
+ rss << duration.count() << " m";
+ return rss.str();
+ }
+ };
+ template<typename Value>
+ struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
+ static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
+ ReusableStringStream rss;
+ rss << duration.count() << " h";
+ return rss.str();
+ }
+ };
+
+ ////////////
+ // std::chrono::time_point specialization
+ // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
+ template<typename Clock, typename Duration>
+ struct StringMaker<std::chrono::time_point<Clock, Duration>> {
+ static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
+ return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
+ }
+ };
+ // std::chrono::time_point<system_clock> specialization
+ template<typename Duration>
+ struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
+ static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
+ auto converted = std::chrono::system_clock::to_time_t(time_point);
+
+#ifdef _MSC_VER
+ std::tm timeInfo = {};
+ gmtime_s(&timeInfo, &converted);
+#else
+ std::tm* timeInfo = std::gmtime(&converted);
+#endif
+
+ auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+ char timeStamp[timeStampSize];
+ const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+ std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+ std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+ return std::string(timeStamp, timeStampSize - 1);
+ }
+ };
+}
+
+
+#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
+namespace Catch { \
+ template<> struct StringMaker<enumName> { \
+ static std::string convert( enumName value ) { \
+ static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
+ return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
+ } \
+ }; \
+}
+
+#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif // CATCH_TOSTRING_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+
+ class Approx {
+ private:
+ bool equalityComparisonImpl(double other) const;
+ // Sets and validates the new margin (margin >= 0)
+ void setMargin(double margin);
+ // Sets and validates the new epsilon (0 < epsilon < 1)
+ void setEpsilon(double epsilon);
+
+ public:
+ explicit Approx ( double value );
+
+ static Approx custom();
+
+ Approx operator-() const;
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ Approx operator()( T const& value ) const {
+ Approx approx( static_cast<double>(value) );
+ approx.m_epsilon = m_epsilon;
+ approx.m_margin = m_margin;
+ approx.m_scale = m_scale;
+ return approx;
+ }
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ explicit Approx( T const& value ): Approx(static_cast<double>(value))
+ {}
+
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ friend bool operator == ( const T& lhs, Approx const& rhs ) {
+ auto lhs_v = static_cast<double>(lhs);
+ return rhs.equalityComparisonImpl(lhs_v);
+ }
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ friend bool operator == ( Approx const& lhs, const T& rhs ) {
+ return operator==( rhs, lhs );
+ }
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ friend bool operator != ( T const& lhs, Approx const& rhs ) {
+ return !operator==( lhs, rhs );
+ }
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ friend bool operator != ( Approx const& lhs, T const& rhs ) {
+ return !operator==( rhs, lhs );
+ }
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ friend bool operator <= ( T const& lhs, Approx const& rhs ) {
+ return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
+ }
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ friend bool operator <= ( Approx const& lhs, T const& rhs ) {
+ return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
+ }
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ friend bool operator >= ( T const& lhs, Approx const& rhs ) {
+ return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
+ }
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ friend bool operator >= ( Approx const& lhs, T const& rhs ) {
+ return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
+ }
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ Approx& epsilon( T const& newEpsilon ) {
+ const auto epsilonAsDouble = static_cast<double>(newEpsilon);
+ setEpsilon(epsilonAsDouble);
+ return *this;
+ }
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ Approx& margin( T const& newMargin ) {
+ const auto marginAsDouble = static_cast<double>(newMargin);
+ setMargin(marginAsDouble);
+ return *this;
+ }
+
+ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ Approx& scale( T const& newScale ) {
+ m_scale = static_cast<double>(newScale);
+ return *this;
+ }
+
+ std::string toString() const;
+
+ private:
+ double m_epsilon;
+ double m_margin;
+ double m_scale;
+ double m_value;
+ };
+
+namespace literals {
+ Approx operator ""_a(long double val);
+ Approx operator ""_a(unsigned long long val);
+} // end namespace literals
+
+template<>
+struct StringMaker<Catch::Approx> {
+ static std::string convert(Catch::Approx const& value);
+};
+
+} // end namespace Catch
+
+#endif // CATCH_APPROX_HPP_INCLUDED
+
+
+#ifndef CATCH_ASSERTION_INFO_HPP_INCLUDED
+#define CATCH_ASSERTION_INFO_HPP_INCLUDED
+
+
+
+#ifndef CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+#define CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+
+#include <cstddef>
+#include <iosfwd>
+
+namespace Catch {
+
+ struct SourceLineInfo {
+
+ SourceLineInfo() = delete;
+ constexpr SourceLineInfo( char const* _file, std::size_t _line ) noexcept:
+ file( _file ),
+ line( _line )
+ {}
+
+ bool operator == ( SourceLineInfo const& other ) const noexcept;
+ bool operator < ( SourceLineInfo const& other ) const noexcept;
+
+ char const* file;
+ std::size_t line;
+
+ friend std::ostream& operator << (std::ostream& os, SourceLineInfo const& info);
+ };
+}
+
+#define CATCH_INTERNAL_LINEINFO \
+ ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+
+#endif // CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+
+namespace Catch {
+
+ struct AssertionInfo {
+ // AssertionInfo() = delete;
+
+ StringRef macroName;
+ SourceLineInfo lineInfo;
+ StringRef capturedExpression;
+ ResultDisposition::Flags resultDisposition;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_ASSERTION_INFO_HPP_INCLUDED
+
+
+#ifndef CATCH_ASSERTION_RESULT_HPP_INCLUDED
+#define CATCH_ASSERTION_RESULT_HPP_INCLUDED
+
+
+
+#ifndef CATCH_LAZY_EXPR_HPP_INCLUDED
+#define CATCH_LAZY_EXPR_HPP_INCLUDED
+
+#include <iosfwd>
+
+namespace Catch {
+
+ class ITransientExpression;
+
+ class LazyExpression {
+ friend class AssertionHandler;
+ friend struct AssertionStats;
+ friend class RunContext;
+
+ ITransientExpression const* m_transientExpression = nullptr;
+ bool m_isNegated;
+ public:
+ LazyExpression( bool isNegated ):
+ m_isNegated(isNegated)
+ {}
+ LazyExpression(LazyExpression const& other) = default;
+ LazyExpression& operator = ( LazyExpression const& ) = delete;
+
+ explicit operator bool() const {
+ return m_transientExpression != nullptr;
+ }
+
+ friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
+ };
+
+} // namespace Catch
+
+#endif // CATCH_LAZY_EXPR_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+ struct AssertionResultData
+ {
+ AssertionResultData() = delete;
+
+ AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+
+ std::string message;
+ mutable std::string reconstructedExpression;
+ LazyExpression lazyExpression;
+ ResultWas::OfType resultType;
+
+ std::string reconstructExpression() const;
+ };
+
+ class AssertionResult {
+ public:
+ AssertionResult() = delete;
+ AssertionResult( AssertionInfo const& info, AssertionResultData&& data );
+
+ bool isOk() const;
+ bool succeeded() const;
+ ResultWas::OfType getResultType() const;
+ bool hasExpression() const;
+ bool hasMessage() const;
+ std::string getExpression() const;
+ std::string getExpressionInMacro() const;
+ bool hasExpandedExpression() const;
+ std::string getExpandedExpression() const;
+ StringRef getMessage() const;
+ SourceLineInfo getSourceInfo() const;
+ StringRef getTestMacroName() const;
+
+ //protected:
+ AssertionInfo m_info;
+ AssertionResultData m_resultData;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_ASSERTION_RESULT_HPP_INCLUDED
+
+
+#ifndef CATCH_CONFIG_HPP_INCLUDED
+#define CATCH_CONFIG_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_SPEC_HPP_INCLUDED
+#define CATCH_TEST_SPEC_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+
+
+#ifndef CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+#define CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+
+
+
+#ifndef CATCH_CASE_SENSITIVE_HPP_INCLUDED
+#define CATCH_CASE_SENSITIVE_HPP_INCLUDED
+
+namespace Catch {
+
+ enum class CaseSensitive { Yes, No };
+
+} // namespace Catch
+
+#endif // CATCH_CASE_SENSITIVE_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch
+{
+ class WildcardPattern {
+ enum WildcardPosition {
+ NoWildcard = 0,
+ WildcardAtStart = 1,
+ WildcardAtEnd = 2,
+ WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+ };
+
+ public:
+
+ WildcardPattern( std::string const& pattern, CaseSensitive caseSensitivity );
+ bool matches( std::string const& str ) const;
+
+ private:
+ std::string normaliseString( std::string const& str ) const;
+ CaseSensitive m_caseSensitivity;
+ WildcardPosition m_wildcard = NoWildcard;
+ std::string m_pattern;
+ };
+}
+
+#endif // CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+ class IConfig;
+ struct TestCaseInfo;
+ class TestCaseHandle;
+
+ class TestSpec {
+
+ class Pattern {
+ public:
+ explicit Pattern( std::string const& name );
+ virtual ~Pattern();
+ virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+ std::string const& name() const;
+ private:
+ virtual void serializeTo( std::ostream& out ) const = 0;
+ // Writes string that would be reparsed into the pattern
+ friend std::ostream& operator<<(std::ostream& out,
+ Pattern const& pattern) {
+ pattern.serializeTo( out );
+ return out;
+ }
+
+ std::string const m_name;
+ };
+
+ class NamePattern : public Pattern {
+ public:
+ explicit NamePattern( std::string const& name, std::string const& filterString );
+ bool matches( TestCaseInfo const& testCase ) const override;
+ private:
+ void serializeTo( std::ostream& out ) const override;
+
+ WildcardPattern m_wildcardPattern;
+ };
+
+ class TagPattern : public Pattern {
+ public:
+ explicit TagPattern( std::string const& tag, std::string const& filterString );
+ bool matches( TestCaseInfo const& testCase ) const override;
+ private:
+ void serializeTo( std::ostream& out ) const override;
+
+ std::string m_tag;
+ };
+
+ struct Filter {
+ std::vector<Detail::unique_ptr<Pattern>> m_required;
+ std::vector<Detail::unique_ptr<Pattern>> m_forbidden;
+
+ //! Serializes this filter into a string that would be parsed into
+ //! an equivalent filter
+ void serializeTo( std::ostream& out ) const;
+ friend std::ostream& operator<<(std::ostream& out, Filter const& f) {
+ f.serializeTo( out );
+ return out;
+ }
+
+ bool matches( TestCaseInfo const& testCase ) const;
+ };
+
+ static std::string extractFilterName( Filter const& filter );
+
+ public:
+ struct FilterMatch {
+ std::string name;
+ std::vector<TestCaseHandle const*> tests;
+ };
+ using Matches = std::vector<FilterMatch>;
+ using vectorStrings = std::vector<std::string>;
+
+ bool hasFilters() const;
+ bool matches( TestCaseInfo const& testCase ) const;
+ Matches matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const;
+ const vectorStrings & getInvalidSpecs() const;
+
+ private:
+ std::vector<Filter> m_filters;
+ std::vector<std::string> m_invalidSpecs;
+
+ friend class TestSpecParser;
+ //! Serializes this test spec into a string that would be parsed into
+ //! equivalent test spec
+ void serializeTo( std::ostream& out ) const;
+ friend std::ostream& operator<<(std::ostream& out,
+ TestSpec const& spec) {
+ spec.serializeTo( out );
+ return out;
+ }
+ };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_TEST_SPEC_HPP_INCLUDED
+
+
+#ifndef CATCH_OPTIONAL_HPP_INCLUDED
+#define CATCH_OPTIONAL_HPP_INCLUDED
+
+
+#include <cassert>
+
+namespace Catch {
+
+ // An optional type
+ template<typename T>
+ class Optional {
+ public:
+ Optional(): nullableValue( nullptr ) {}
+ ~Optional() { reset(); }
+
+ Optional( T const& _value ):
+ nullableValue( new ( storage ) T( _value ) ) {}
+ Optional( T&& _value ):
+ nullableValue( new ( storage ) T( CATCH_MOVE( _value ) ) ) {}
+
+ Optional& operator=( T const& _value ) {
+ reset();
+ nullableValue = new ( storage ) T( _value );
+ return *this;
+ }
+ Optional& operator=( T&& _value ) {
+ reset();
+ nullableValue = new ( storage ) T( CATCH_MOVE( _value ) );
+ return *this;
+ }
+
+ Optional( Optional const& _other ):
+ nullableValue( _other ? new ( storage ) T( *_other ) : nullptr ) {}
+ Optional( Optional&& _other ):
+ nullableValue( _other ? new ( storage ) T( CATCH_MOVE( *_other ) )
+ : nullptr ) {}
+
+ Optional& operator=( Optional const& _other ) {
+ if ( &_other != this ) {
+ reset();
+ if ( _other ) { nullableValue = new ( storage ) T( *_other ); }
+ }
+ return *this;
+ }
+ Optional& operator=( Optional&& _other ) {
+ if ( &_other != this ) {
+ reset();
+ if ( _other ) {
+ nullableValue = new ( storage ) T( CATCH_MOVE( *_other ) );
+ }
+ }
+ return *this;
+ }
+
+ void reset() {
+ if ( nullableValue ) { nullableValue->~T(); }
+ nullableValue = nullptr;
+ }
+
+ T& operator*() {
+ assert(nullableValue);
+ return *nullableValue;
+ }
+ T const& operator*() const {
+ assert(nullableValue);
+ return *nullableValue;
+ }
+ T* operator->() {
+ assert(nullableValue);
+ return nullableValue;
+ }
+ const T* operator->() const {
+ assert(nullableValue);
+ return nullableValue;
+ }
+
+ T valueOr( T const& defaultValue ) const {
+ return nullableValue ? *nullableValue : defaultValue;
+ }
+
+ bool some() const { return nullableValue != nullptr; }
+ bool none() const { return nullableValue == nullptr; }
+
+ bool operator !() const { return nullableValue == nullptr; }
+ explicit operator bool() const {
+ return some();
+ }
+
+ friend bool operator==(Optional const& a, Optional const& b) {
+ if (a.none() && b.none()) {
+ return true;
+ } else if (a.some() && b.some()) {
+ return *a == *b;
+ } else {
+ return false;
+ }
+ }
+ friend bool operator!=(Optional const& a, Optional const& b) {
+ return !( a == b );
+ }
+
+ private:
+ T* nullableValue;
+ alignas(alignof(T)) char storage[sizeof(T)];
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_OPTIONAL_HPP_INCLUDED
+
+
+#ifndef CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+#define CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+ enum class GenerateFrom {
+ Time,
+ RandomDevice,
+ //! Currently equivalent to RandomDevice, but can change at any point
+ Default
+ };
+
+ std::uint32_t generateRandomSeed(GenerateFrom from);
+
+} // end namespace Catch
+
+#endif // CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+#define CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+ enum class ColourMode : std::uint8_t;
+
+ namespace Detail {
+ //! Splits the reporter spec into reporter name and kv-pair options
+ std::vector<std::string> splitReporterSpec( StringRef reporterSpec );
+
+ Optional<ColourMode> stringToColourMode( StringRef colourMode );
+ }
+
+ /**
+ * Structured reporter spec that a reporter can be created from
+ *
+ * Parsing has been validated, but semantics have not. This means e.g.
+ * that the colour mode is known to Catch2, but it might not be
+ * compiled into the binary, and the output filename might not be
+ * openable.
+ */
+ class ReporterSpec {
+ std::string m_name;
+ Optional<std::string> m_outputFileName;
+ Optional<ColourMode> m_colourMode;
+ std::map<std::string, std::string> m_customOptions;
+
+ friend bool operator==( ReporterSpec const& lhs,
+ ReporterSpec const& rhs );
+ friend bool operator!=( ReporterSpec const& lhs,
+ ReporterSpec const& rhs ) {
+ return !( lhs == rhs );
+ }
+
+ public:
+ ReporterSpec(
+ std::string name,
+ Optional<std::string> outputFileName,
+ Optional<ColourMode> colourMode,
+ std::map<std::string, std::string> customOptions );
+
+ std::string const& name() const { return m_name; }
+
+ Optional<std::string> const& outputFile() const {
+ return m_outputFileName;
+ }
+
+ Optional<ColourMode> const& colourMode() const { return m_colourMode; }
+
+ std::map<std::string, std::string> const& customOptions() const {
+ return m_customOptions;
+ }
+ };
+
+ /**
+ * Parses provided reporter spec string into
+ *
+ * Returns empty optional on errors, e.g.
+ * * field that is not first and not a key+value pair
+ * * duplicated keys in kv pair
+ * * unknown catch reporter option
+ * * empty key/value in an custom kv pair
+ * * ...
+ */
+ Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec );
+
+}
+
+#endif // CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+
+#include <chrono>
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+ class IStream;
+
+ /**
+ * `ReporterSpec` but with the defaults filled in.
+ *
+ * Like `ReporterSpec`, the semantics are unchecked.
+ */
+ struct ProcessedReporterSpec {
+ std::string name;
+ std::string outputFilename;
+ ColourMode colourMode;
+ std::map<std::string, std::string> customOptions;
+ friend bool operator==( ProcessedReporterSpec const& lhs,
+ ProcessedReporterSpec const& rhs );
+ friend bool operator!=( ProcessedReporterSpec const& lhs,
+ ProcessedReporterSpec const& rhs ) {
+ return !( lhs == rhs );
+ }
+ };
+
+ struct ConfigData {
+
+ bool listTests = false;
+ bool listTags = false;
+ bool listReporters = false;
+ bool listListeners = false;
+
+ bool showSuccessfulTests = false;
+ bool shouldDebugBreak = false;
+ bool noThrow = false;
+ bool showHelp = false;
+ bool showInvisibles = false;
+ bool filenamesAsTags = false;
+ bool libIdentify = false;
+ bool allowZeroTests = false;
+
+ int abortAfter = -1;
+ uint32_t rngSeed = generateRandomSeed(GenerateFrom::Default);
+
+ unsigned int shardCount = 1;
+ unsigned int shardIndex = 0;
+
+ bool skipBenchmarks = false;
+ bool benchmarkNoAnalysis = false;
+ unsigned int benchmarkSamples = 100;
+ double benchmarkConfidenceInterval = 0.95;
+ unsigned int benchmarkResamples = 100'000;
+ std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
+
+ Verbosity verbosity = Verbosity::Normal;
+ WarnAbout::What warnings = WarnAbout::Nothing;
+ ShowDurations showDurations = ShowDurations::DefaultForReporter;
+ double minDuration = -1;
+ TestRunOrder runOrder = TestRunOrder::Declared;
+ ColourMode defaultColourMode = ColourMode::PlatformDefault;
+ WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+
+ std::string defaultOutputFilename;
+ std::string name;
+ std::string processName;
+ std::vector<ReporterSpec> reporterSpecifications;
+
+ std::vector<std::string> testsOrTags;
+ std::vector<std::string> sectionsToRun;
+ };
+
+
+ class Config : public IConfig {
+ public:
+
+ Config() = default;
+ Config( ConfigData const& data );
+ ~Config() override; // = default in the cpp file
+
+ bool listTests() const;
+ bool listTags() const;
+ bool listReporters() const;
+ bool listListeners() const;
+
+ std::vector<ReporterSpec> const& getReporterSpecs() const;
+ std::vector<ProcessedReporterSpec> const&
+ getProcessedReporterSpecs() const;
+
+ std::vector<std::string> const& getTestsOrTags() const override;
+ std::vector<std::string> const& getSectionsToRun() const override;
+
+ TestSpec const& testSpec() const override;
+ bool hasTestFilters() const override;
+
+ bool showHelp() const;
+
+ // IConfig interface
+ bool allowThrows() const override;
+ StringRef name() const override;
+ bool includeSuccessfulResults() const override;
+ bool warnAboutMissingAssertions() const override;
+ bool warnAboutUnmatchedTestSpecs() const override;
+ bool zeroTestsCountAsSuccess() const override;
+ ShowDurations showDurations() const override;
+ double minDuration() const override;
+ TestRunOrder runOrder() const override;
+ uint32_t rngSeed() const override;
+ unsigned int shardCount() const override;
+ unsigned int shardIndex() const override;
+ ColourMode defaultColourMode() const override;
+ bool shouldDebugBreak() const override;
+ int abortAfter() const override;
+ bool showInvisibles() const override;
+ Verbosity verbosity() const override;
+ bool skipBenchmarks() const override;
+ bool benchmarkNoAnalysis() const override;
+ unsigned int benchmarkSamples() const override;
+ double benchmarkConfidenceInterval() const override;
+ unsigned int benchmarkResamples() const override;
+ std::chrono::milliseconds benchmarkWarmupTime() const override;
+
+ private:
+ // Reads Bazel env vars and applies them to the config
+ void readBazelEnvVars();
+
+ ConfigData m_data;
+ std::vector<ProcessedReporterSpec> m_processedReporterSpecs;
+ TestSpec m_testSpec;
+ bool m_hasTestFilters = false;
+ };
+} // end namespace Catch
+
+#endif // CATCH_CONFIG_HPP_INCLUDED
+
+
+#ifndef CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+#define CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+ //! Returns Catch2's current RNG seed.
+ std::uint32_t getSeed();
+}
+
+#endif // CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+
+
+#ifndef CATCH_MESSAGE_HPP_INCLUDED
+#define CATCH_MESSAGE_HPP_INCLUDED
+
+
+
+
+/** \file
+ * Wrapper for the CATCH_CONFIG_PREFIX_MESSAGES configuration option
+ *
+ * CATCH_CONFIG_PREFIX_ALL can be used to avoid clashes with other macros
+ * by prepending CATCH_. This may not be desirable if the only clashes are with
+ * logger macros such as INFO and WARN. In this cases
+ * CATCH_CONFIG_PREFIX_MESSAGES can be used to only prefix a small subset
+ * of relevant macros.
+ *
+ */
+
+#ifndef CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
+#define CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
+
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_PREFIX_MESSAGES)
+ #define CATCH_CONFIG_PREFIX_MESSAGES
+#endif
+
+#endif // CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
+
+
+#ifndef CATCH_STREAM_END_STOP_HPP_INCLUDED
+#define CATCH_STREAM_END_STOP_HPP_INCLUDED
+
+
+namespace Catch {
+
+ // Use this in variadic streaming macros to allow
+ // << +StreamEndStop
+ // as well as
+ // << stuff +StreamEndStop
+ struct StreamEndStop {
+ constexpr StringRef operator+() const { return StringRef(); }
+
+ template <typename T>
+ constexpr friend T const& operator+( T const& value, StreamEndStop ) {
+ return value;
+ }
+ };
+
+} // namespace Catch
+
+#endif // CATCH_STREAM_END_STOP_HPP_INCLUDED
+
+
+#ifndef CATCH_MESSAGE_INFO_HPP_INCLUDED
+#define CATCH_MESSAGE_INFO_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+ struct MessageInfo {
+ MessageInfo( StringRef _macroName,
+ SourceLineInfo const& _lineInfo,
+ ResultWas::OfType _type );
+
+ StringRef macroName;
+ std::string message;
+ SourceLineInfo lineInfo;
+ ResultWas::OfType type;
+ unsigned int sequence;
+
+ bool operator == (MessageInfo const& other) const {
+ return sequence == other.sequence;
+ }
+ bool operator < (MessageInfo const& other) const {
+ return sequence < other.sequence;
+ }
+ private:
+ static unsigned int globalCount;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_MESSAGE_INFO_HPP_INCLUDED
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+ struct SourceLineInfo;
+ class IResultCapture;
+
+ struct MessageStream {
+
+ template<typename T>
+ MessageStream& operator << ( T const& value ) {
+ m_stream << value;
+ return *this;
+ }
+
+ ReusableStringStream m_stream;
+ };
+
+ struct MessageBuilder : MessageStream {
+ MessageBuilder( StringRef macroName,
+ SourceLineInfo const& lineInfo,
+ ResultWas::OfType type ):
+ m_info(macroName, lineInfo, type) {}
+
+ template<typename T>
+ MessageBuilder&& operator << ( T const& value ) && {
+ m_stream << value;
+ return CATCH_MOVE(*this);
+ }
+
+ MessageInfo m_info;
+ };
+
+ class ScopedMessage {
+ public:
+ explicit ScopedMessage( MessageBuilder&& builder );
+ ScopedMessage( ScopedMessage& duplicate ) = delete;
+ ScopedMessage( ScopedMessage&& old ) noexcept;
+ ~ScopedMessage();
+
+ MessageInfo m_info;
+ bool m_moved = false;
+ };
+
+ class Capturer {
+ std::vector<MessageInfo> m_messages;
+ IResultCapture& m_resultCapture;
+ size_t m_captured = 0;
+ public:
+ Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
+
+ Capturer(Capturer const&) = delete;
+ Capturer& operator=(Capturer const&) = delete;
+
+ ~Capturer();
+
+ void captureValue( size_t index, std::string const& value );
+
+ template<typename T>
+ void captureValues( size_t index, T const& value ) {
+ captureValue( index, Catch::Detail::stringify( value ) );
+ }
+
+ template<typename T, typename... Ts>
+ void captureValues( size_t index, T const& value, Ts const&... values ) {
+ captureValue( index, Catch::Detail::stringify(value) );
+ captureValues( index+1, values... );
+ }
+ };
+
+} // end namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+ do { \
+ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
+ catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
+ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+ } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
+ Catch::Capturer varName( macroName##_catch_sr, \
+ CATCH_INTERNAL_LINEINFO, \
+ Catch::ResultWas::Info, \
+ #__VA_ARGS__##_catch_sr ); \
+ varName.captureValues( 0, __VA_ARGS__ )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_INFO( macroName, log ) \
+ const Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
+ Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
+
+#if defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)
+
+ #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+ #define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
+ #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+ #define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE", __VA_ARGS__ )
+
+#elif defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)
+
+ #define CATCH_INFO( msg ) (void)(0)
+ #define CATCH_UNSCOPED_INFO( msg ) (void)(0)
+ #define CATCH_WARN( msg ) (void)(0)
+ #define CATCH_CAPTURE( ... ) (void)(0)
+
+#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)
+
+ #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+ #define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
+ #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+ #define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE", __VA_ARGS__ )
+
+#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)
+
+ #define INFO( msg ) (void)(0)
+ #define UNSCOPED_INFO( msg ) (void)(0)
+ #define WARN( msg ) (void)(0)
+ #define CAPTURE( ... ) (void)(0)
+
+#endif // end of user facing macro declarations
+
+
+
+
+#endif // CATCH_MESSAGE_HPP_INCLUDED
+
+
+#ifndef CATCH_SECTION_INFO_HPP_INCLUDED
+#define CATCH_SECTION_INFO_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TOTALS_HPP_INCLUDED
+#define CATCH_TOTALS_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+ struct Counts {
+ Counts operator - ( Counts const& other ) const;
+ Counts& operator += ( Counts const& other );
+
+ std::uint64_t total() const;
+ bool allPassed() const;
+ bool allOk() const;
+
+ std::uint64_t passed = 0;
+ std::uint64_t failed = 0;
+ std::uint64_t failedButOk = 0;
+ std::uint64_t skipped = 0;
+ };
+
+ struct Totals {
+
+ Totals operator - ( Totals const& other ) const;
+ Totals& operator += ( Totals const& other );
+
+ Totals delta( Totals const& prevTotals ) const;
+
+ Counts assertions;
+ Counts testCases;
+ };
+}
+
+#endif // CATCH_TOTALS_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+ struct SectionInfo {
+ // The last argument is ignored, so that people can write
+ // SECTION("ShortName", "Proper description that is long") and
+ // still use the `-c` flag comfortably.
+ SectionInfo( SourceLineInfo const& _lineInfo, std::string _name,
+ const char* const = nullptr ):
+ name(CATCH_MOVE(_name)),
+ lineInfo(_lineInfo)
+ {}
+
+ std::string name;
+ SourceLineInfo lineInfo;
+ };
+
+ struct SectionEndInfo {
+ SectionInfo sectionInfo;
+ Counts prevAssertions;
+ double durationInSeconds;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_SECTION_INFO_HPP_INCLUDED
+
+
+#ifndef CATCH_SESSION_HPP_INCLUDED
+#define CATCH_SESSION_HPP_INCLUDED
+
+
+
+#ifndef CATCH_COMMANDLINE_HPP_INCLUDED
+#define CATCH_COMMANDLINE_HPP_INCLUDED
+
+
+
+#ifndef CATCH_CLARA_HPP_INCLUDED
+#define CATCH_CLARA_HPP_INCLUDED
+
+#if defined( __clang__ )
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wweak-vtables"
+# pragma clang diagnostic ignored "-Wshadow"
+# pragma clang diagnostic ignored "-Wdeprecated"
+#endif
+
+#if defined( __GNUC__ )
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+#ifndef CLARA_CONFIG_OPTIONAL_TYPE
+# ifdef __has_include
+# if __has_include( <optional>) && __cplusplus >= 201703L
+# include <optional>
+# define CLARA_CONFIG_OPTIONAL_TYPE std::optional
+# endif
+# endif
+#endif
+
+
+#include <cassert>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace Catch {
+ namespace Clara {
+
+ class Args;
+ class Parser;
+
+ // enum of result types from a parse
+ enum class ParseResultType {
+ Matched,
+ NoMatch,
+ ShortCircuitAll,
+ ShortCircuitSame
+ };
+
+ struct accept_many_t {};
+ constexpr accept_many_t accept_many {};
+
+ namespace Detail {
+ struct fake_arg {
+ template <typename T>
+ operator T();
+ };
+
+ template <typename F, typename = void>
+ struct is_unary_function : std::false_type {};
+
+ template <typename F>
+ struct is_unary_function<
+ F,
+ Catch::Detail::void_t<decltype(
+ std::declval<F>()( fake_arg() ) )
+ >
+ > : std::true_type {};
+
+ // Traits for extracting arg and return type of lambdas (for single
+ // argument lambdas)
+ template <typename L>
+ struct UnaryLambdaTraits
+ : UnaryLambdaTraits<decltype( &L::operator() )> {};
+
+ template <typename ClassT, typename ReturnT, typename... Args>
+ struct UnaryLambdaTraits<ReturnT ( ClassT::* )( Args... ) const> {
+ static const bool isValid = false;
+ };
+
+ template <typename ClassT, typename ReturnT, typename ArgT>
+ struct UnaryLambdaTraits<ReturnT ( ClassT::* )( ArgT ) const> {
+ static const bool isValid = true;
+ using ArgType = std::remove_const_t<std::remove_reference_t<ArgT>>;
+ using ReturnType = ReturnT;
+ };
+
+ class TokenStream;
+
+ // Wraps a token coming from a token stream. These may not directly
+ // correspond to strings as a single string may encode an option +
+ // its argument if the : or = form is used
+ enum class TokenType { Option, Argument };
+ struct Token {
+ TokenType type;
+ StringRef token;
+ };
+
+ // Abstracts iterators into args as a stream of tokens, with option
+ // arguments uniformly handled
+ class TokenStream {
+ using Iterator = std::vector<StringRef>::const_iterator;
+ Iterator it;
+ Iterator itEnd;
+ std::vector<Token> m_tokenBuffer;
+ void loadBuffer();
+
+ public:
+ explicit TokenStream( Args const& args );
+ TokenStream( Iterator it, Iterator itEnd );
+
+ explicit operator bool() const {
+ return !m_tokenBuffer.empty() || it != itEnd;
+ }
+
+ size_t count() const {
+ return m_tokenBuffer.size() + ( itEnd - it );
+ }
+
+ Token operator*() const {
+ assert( !m_tokenBuffer.empty() );
+ return m_tokenBuffer.front();
+ }
+
+ Token const* operator->() const {
+ assert( !m_tokenBuffer.empty() );
+ return &m_tokenBuffer.front();
+ }
+
+ TokenStream& operator++();
+ };
+
+ //! Denotes type of a parsing result
+ enum class ResultType {
+ Ok, ///< No errors
+ LogicError, ///< Error in user-specified arguments for
+ ///< construction
+ RuntimeError ///< Error in parsing inputs
+ };
+
+ class ResultBase {
+ protected:
+ ResultBase( ResultType type ): m_type( type ) {}
+ virtual ~ResultBase(); // = default;
+
+
+ ResultBase(ResultBase const&) = default;
+ ResultBase& operator=(ResultBase const&) = default;
+ ResultBase(ResultBase&&) = default;
+ ResultBase& operator=(ResultBase&&) = default;
+
+ virtual void enforceOk() const = 0;
+
+ ResultType m_type;
+ };
+
+ template <typename T>
+ class ResultValueBase : public ResultBase {
+ public:
+ T const& value() const& {
+ enforceOk();
+ return m_value;
+ }
+ T&& value() && {
+ enforceOk();
+ return CATCH_MOVE( m_value );
+ }
+
+ protected:
+ ResultValueBase( ResultType type ): ResultBase( type ) {}
+
+ ResultValueBase( ResultValueBase const& other ):
+ ResultBase( other ) {
+ if ( m_type == ResultType::Ok )
+ new ( &m_value ) T( other.m_value );
+ }
+ ResultValueBase( ResultValueBase&& other ):
+ ResultBase( other ) {
+ if ( m_type == ResultType::Ok )
+ new ( &m_value ) T( CATCH_MOVE(other.m_value) );
+ }
+
+
+ ResultValueBase( ResultType, T const& value ):
+ ResultBase( ResultType::Ok ) {
+ new ( &m_value ) T( value );
+ }
+ ResultValueBase( ResultType, T&& value ):
+ ResultBase( ResultType::Ok ) {
+ new ( &m_value ) T( CATCH_MOVE(value) );
+ }
+
+ ResultValueBase& operator=( ResultValueBase const& other ) {
+ if ( m_type == ResultType::Ok )
+ m_value.~T();
+ ResultBase::operator=( other );
+ if ( m_type == ResultType::Ok )
+ new ( &m_value ) T( other.m_value );
+ return *this;
+ }
+ ResultValueBase& operator=( ResultValueBase&& other ) {
+ if ( m_type == ResultType::Ok ) m_value.~T();
+ ResultBase::operator=( other );
+ if ( m_type == ResultType::Ok )
+ new ( &m_value ) T( CATCH_MOVE(other.m_value) );
+ return *this;
+ }
+
+
+ ~ResultValueBase() override {
+ if ( m_type == ResultType::Ok )
+ m_value.~T();
+ }
+
+ union {
+ T m_value;
+ };
+ };
+
+ template <> class ResultValueBase<void> : public ResultBase {
+ protected:
+ using ResultBase::ResultBase;
+ };
+
+ template <typename T = void>
+ class BasicResult : public ResultValueBase<T> {
+ public:
+ template <typename U>
+ explicit BasicResult( BasicResult<U> const& other ):
+ ResultValueBase<T>( other.type() ),
+ m_errorMessage( other.errorMessage() ) {
+ assert( type() != ResultType::Ok );
+ }
+
+ template <typename U>
+ static auto ok( U&& value ) -> BasicResult {
+ return { ResultType::Ok, CATCH_FORWARD(value) };
+ }
+ static auto ok() -> BasicResult { return { ResultType::Ok }; }
+ static auto logicError( std::string&& message )
+ -> BasicResult {
+ return { ResultType::LogicError, CATCH_MOVE(message) };
+ }
+ static auto runtimeError( std::string&& message )
+ -> BasicResult {
+ return { ResultType::RuntimeError, CATCH_MOVE(message) };
+ }
+
+ explicit operator bool() const {
+ return m_type == ResultType::Ok;
+ }
+ auto type() const -> ResultType { return m_type; }
+ auto errorMessage() const -> std::string const& {
+ return m_errorMessage;
+ }
+
+ protected:
+ void enforceOk() const override {
+
+ // Errors shouldn't reach this point, but if they do
+ // the actual error message will be in m_errorMessage
+ assert( m_type != ResultType::LogicError );
+ assert( m_type != ResultType::RuntimeError );
+ if ( m_type != ResultType::Ok )
+ std::abort();
+ }
+
+ std::string
+ m_errorMessage; // Only populated if resultType is an error
+
+ BasicResult( ResultType type,
+ std::string&& message ):
+ ResultValueBase<T>( type ), m_errorMessage( CATCH_MOVE(message) ) {
+ assert( m_type != ResultType::Ok );
+ }
+
+ using ResultValueBase<T>::ResultValueBase;
+ using ResultBase::m_type;
+ };
+
+ class ParseState {
+ public:
+ ParseState( ParseResultType type,
+ TokenStream remainingTokens );
+
+ ParseResultType type() const { return m_type; }
+ TokenStream const& remainingTokens() const& {
+ return m_remainingTokens;
+ }
+ TokenStream&& remainingTokens() && {
+ return CATCH_MOVE( m_remainingTokens );
+ }
+
+ private:
+ ParseResultType m_type;
+ TokenStream m_remainingTokens;
+ };
+
+ using Result = BasicResult<void>;
+ using ParserResult = BasicResult<ParseResultType>;
+ using InternalParseResult = BasicResult<ParseState>;
+
+ struct HelpColumns {
+ std::string left;
+ StringRef descriptions;
+ };
+
+ template <typename T>
+ ParserResult convertInto( std::string const& source, T& target ) {
+ std::stringstream ss( source );
+ ss >> target;
+ if ( ss.fail() ) {
+ return ParserResult::runtimeError(
+ "Unable to convert '" + source +
+ "' to destination type" );
+ } else {
+ return ParserResult::ok( ParseResultType::Matched );
+ }
+ }
+ ParserResult convertInto( std::string const& source,
+ std::string& target );
+ ParserResult convertInto( std::string const& source, bool& target );
+
+#ifdef CLARA_CONFIG_OPTIONAL_TYPE
+ template <typename T>
+ auto convertInto( std::string const& source,
+ CLARA_CONFIG_OPTIONAL_TYPE<T>& target )
+ -> ParserResult {
+ T temp;
+ auto result = convertInto( source, temp );
+ if ( result )
+ target = CATCH_MOVE( temp );
+ return result;
+ }
+#endif // CLARA_CONFIG_OPTIONAL_TYPE
+
+ struct BoundRef : Catch::Detail::NonCopyable {
+ virtual ~BoundRef() = default;
+ virtual bool isContainer() const;
+ virtual bool isFlag() const;
+ };
+ struct BoundValueRefBase : BoundRef {
+ virtual auto setValue( std::string const& arg )
+ -> ParserResult = 0;
+ };
+ struct BoundFlagRefBase : BoundRef {
+ virtual auto setFlag( bool flag ) -> ParserResult = 0;
+ bool isFlag() const override;
+ };
+
+ template <typename T> struct BoundValueRef : BoundValueRefBase {
+ T& m_ref;
+
+ explicit BoundValueRef( T& ref ): m_ref( ref ) {}
+
+ ParserResult setValue( std::string const& arg ) override {
+ return convertInto( arg, m_ref );
+ }
+ };
+
+ template <typename T>
+ struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
+ std::vector<T>& m_ref;
+
+ explicit BoundValueRef( std::vector<T>& ref ): m_ref( ref ) {}
+
+ auto isContainer() const -> bool override { return true; }
+
+ auto setValue( std::string const& arg )
+ -> ParserResult override {
+ T temp;
+ auto result = convertInto( arg, temp );
+ if ( result )
+ m_ref.push_back( temp );
+ return result;
+ }
+ };
+
+ struct BoundFlagRef : BoundFlagRefBase {
+ bool& m_ref;
+
+ explicit BoundFlagRef( bool& ref ): m_ref( ref ) {}
+
+ ParserResult setFlag( bool flag ) override;
+ };
+
+ template <typename ReturnType> struct LambdaInvoker {
+ static_assert(
+ std::is_same<ReturnType, ParserResult>::value,
+ "Lambda must return void or clara::ParserResult" );
+
+ template <typename L, typename ArgType>
+ static auto invoke( L const& lambda, ArgType const& arg )
+ -> ParserResult {
+ return lambda( arg );
+ }
+ };
+
+ template <> struct LambdaInvoker<void> {
+ template <typename L, typename ArgType>
+ static auto invoke( L const& lambda, ArgType const& arg )
+ -> ParserResult {
+ lambda( arg );
+ return ParserResult::ok( ParseResultType::Matched );
+ }
+ };
+
+ template <typename ArgType, typename L>
+ auto invokeLambda( L const& lambda, std::string const& arg )
+ -> ParserResult {
+ ArgType temp{};
+ auto result = convertInto( arg, temp );
+ return !result ? result
+ : LambdaInvoker<typename UnaryLambdaTraits<
+ L>::ReturnType>::invoke( lambda, temp );
+ }
+
+ template <typename L> struct BoundLambda : BoundValueRefBase {
+ L m_lambda;
+
+ static_assert(
+ UnaryLambdaTraits<L>::isValid,
+ "Supplied lambda must take exactly one argument" );
+ explicit BoundLambda( L const& lambda ): m_lambda( lambda ) {}
+
+ auto setValue( std::string const& arg )
+ -> ParserResult override {
+ return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
+ m_lambda, arg );
+ }
+ };
+
+ template <typename L> struct BoundManyLambda : BoundLambda<L> {
+ explicit BoundManyLambda( L const& lambda ): BoundLambda<L>( lambda ) {}
+ bool isContainer() const override { return true; }
+ };
+
+ template <typename L> struct BoundFlagLambda : BoundFlagRefBase {
+ L m_lambda;
+
+ static_assert(
+ UnaryLambdaTraits<L>::isValid,
+ "Supplied lambda must take exactly one argument" );
+ static_assert(
+ std::is_same<typename UnaryLambdaTraits<L>::ArgType,
+ bool>::value,
+ "flags must be boolean" );
+
+ explicit BoundFlagLambda( L const& lambda ):
+ m_lambda( lambda ) {}
+
+ auto setFlag( bool flag ) -> ParserResult override {
+ return LambdaInvoker<typename UnaryLambdaTraits<
+ L>::ReturnType>::invoke( m_lambda, flag );
+ }
+ };
+
+ enum class Optionality { Optional, Required };
+
+ class ParserBase {
+ public:
+ virtual ~ParserBase() = default;
+ virtual auto validate() const -> Result { return Result::ok(); }
+ virtual auto parse( std::string const& exeName,
+ TokenStream tokens ) const
+ -> InternalParseResult = 0;
+ virtual size_t cardinality() const;
+
+ InternalParseResult parse( Args const& args ) const;
+ };
+
+ template <typename DerivedT>
+ class ComposableParserImpl : public ParserBase {
+ public:
+ template <typename T>
+ auto operator|( T const& other ) const -> Parser;
+ };
+
+ // Common code and state for Args and Opts
+ template <typename DerivedT>
+ class ParserRefImpl : public ComposableParserImpl<DerivedT> {
+ protected:
+ Optionality m_optionality = Optionality::Optional;
+ std::shared_ptr<BoundRef> m_ref;
+ StringRef m_hint;
+ StringRef m_description;
+
+ explicit ParserRefImpl( std::shared_ptr<BoundRef> const& ref ):
+ m_ref( ref ) {}
+
+ public:
+ template <typename LambdaT>
+ ParserRefImpl( accept_many_t,
+ LambdaT const& ref,
+ StringRef hint ):
+ m_ref( std::make_shared<BoundManyLambda<LambdaT>>( ref ) ),
+ m_hint( hint ) {}
+
+ template <typename T,
+ typename = typename std::enable_if_t<
+ !Detail::is_unary_function<T>::value>>
+ ParserRefImpl( T& ref, StringRef hint ):
+ m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+ m_hint( hint ) {}
+
+ template <typename LambdaT,
+ typename = typename std::enable_if_t<
+ Detail::is_unary_function<LambdaT>::value>>
+ ParserRefImpl( LambdaT const& ref, StringRef hint ):
+ m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
+ m_hint( hint ) {}
+
+ DerivedT& operator()( StringRef description ) & {
+ m_description = description;
+ return static_cast<DerivedT&>( *this );
+ }
+ DerivedT&& operator()( StringRef description ) && {
+ m_description = description;
+ return static_cast<DerivedT&&>( *this );
+ }
+
+ auto optional() -> DerivedT& {
+ m_optionality = Optionality::Optional;
+ return static_cast<DerivedT&>( *this );
+ }
+
+ auto required() -> DerivedT& {
+ m_optionality = Optionality::Required;
+ return static_cast<DerivedT&>( *this );
+ }
+
+ auto isOptional() const -> bool {
+ return m_optionality == Optionality::Optional;
+ }
+
+ auto cardinality() const -> size_t override {
+ if ( m_ref->isContainer() )
+ return 0;
+ else
+ return 1;
+ }
+
+ StringRef hint() const { return m_hint; }
+ };
+
+ } // namespace detail
+
+
+ // A parser for arguments
+ class Arg : public Detail::ParserRefImpl<Arg> {
+ public:
+ using ParserRefImpl::ParserRefImpl;
+ using ParserBase::parse;
+
+ Detail::InternalParseResult
+ parse(std::string const&,
+ Detail::TokenStream tokens) const override;
+ };
+
+ // A parser for options
+ class Opt : public Detail::ParserRefImpl<Opt> {
+ protected:
+ std::vector<StringRef> m_optNames;
+
+ public:
+ template <typename LambdaT>
+ explicit Opt(LambdaT const& ref) :
+ ParserRefImpl(
+ std::make_shared<Detail::BoundFlagLambda<LambdaT>>(ref)) {}
+
+ explicit Opt(bool& ref);
+
+ template <typename LambdaT,
+ typename = typename std::enable_if_t<
+ Detail::is_unary_function<LambdaT>::value>>
+ Opt( LambdaT const& ref, StringRef hint ):
+ ParserRefImpl( ref, hint ) {}
+
+ template <typename LambdaT>
+ Opt( accept_many_t, LambdaT const& ref, StringRef hint ):
+ ParserRefImpl( accept_many, ref, hint ) {}
+
+ template <typename T,
+ typename = typename std::enable_if_t<
+ !Detail::is_unary_function<T>::value>>
+ Opt( T& ref, StringRef hint ):
+ ParserRefImpl( ref, hint ) {}
+
+ Opt& operator[]( StringRef optName ) & {
+ m_optNames.push_back(optName);
+ return *this;
+ }
+ Opt&& operator[]( StringRef optName ) && {
+ m_optNames.push_back( optName );
+ return CATCH_MOVE(*this);
+ }
+
+ Detail::HelpColumns getHelpColumns() const;
+
+ bool isMatch(StringRef optToken) const;
+
+ using ParserBase::parse;
+
+ Detail::InternalParseResult
+ parse(std::string const&,
+ Detail::TokenStream tokens) const override;
+
+ Detail::Result validate() const override;
+ };
+
+ // Specifies the name of the executable
+ class ExeName : public Detail::ComposableParserImpl<ExeName> {
+ std::shared_ptr<std::string> m_name;
+ std::shared_ptr<Detail::BoundValueRefBase> m_ref;
+
+ public:
+ ExeName();
+ explicit ExeName(std::string& ref);
+
+ template <typename LambdaT>
+ explicit ExeName(LambdaT const& lambda) : ExeName() {
+ m_ref = std::make_shared<Detail::BoundLambda<LambdaT>>(lambda);
+ }
+
+ // The exe name is not parsed out of the normal tokens, but is
+ // handled specially
+ Detail::InternalParseResult
+ parse(std::string const&,
+ Detail::TokenStream tokens) const override;
+
+ std::string const& name() const { return *m_name; }
+ Detail::ParserResult set(std::string const& newName);
+ };
+
+
+ // A Combined parser
+ class Parser : Detail::ParserBase {
+ mutable ExeName m_exeName;
+ std::vector<Opt> m_options;
+ std::vector<Arg> m_args;
+
+ public:
+
+ auto operator|=(ExeName const& exeName) -> Parser& {
+ m_exeName = exeName;
+ return *this;
+ }
+
+ auto operator|=(Arg const& arg) -> Parser& {
+ m_args.push_back(arg);
+ return *this;
+ }
+
+ friend Parser& operator|=( Parser& p, Opt const& opt ) {
+ p.m_options.push_back( opt );
+ return p;
+ }
+ friend Parser& operator|=( Parser& p, Opt&& opt ) {
+ p.m_options.push_back( CATCH_MOVE(opt) );
+ return p;
+ }
+
+ Parser& operator|=(Parser const& other);
+
+ template <typename T>
+ friend Parser operator|( Parser const& p, T&& rhs ) {
+ Parser temp( p );
+ temp |= rhs;
+ return temp;
+ }
+
+ template <typename T>
+ friend Parser operator|( Parser&& p, T&& rhs ) {
+ p |= CATCH_FORWARD(rhs);
+ return CATCH_MOVE(p);
+ }
+
+ std::vector<Detail::HelpColumns> getHelpColumns() const;
+
+ void writeToStream(std::ostream& os) const;
+
+ friend auto operator<<(std::ostream& os, Parser const& parser)
+ -> std::ostream& {
+ parser.writeToStream(os);
+ return os;
+ }
+
+ Detail::Result validate() const override;
+
+ using ParserBase::parse;
+ Detail::InternalParseResult
+ parse(std::string const& exeName,
+ Detail::TokenStream tokens) const override;
+ };
+
+ /**
+ * Wrapper over argc + argv, assumes that the inputs outlive it
+ */
+ class Args {
+ friend Detail::TokenStream;
+ StringRef m_exeName;
+ std::vector<StringRef> m_args;
+
+ public:
+ Args(int argc, char const* const* argv);
+ // Helper constructor for testing
+ Args(std::initializer_list<StringRef> args);
+
+ StringRef exeName() const { return m_exeName; }
+ };
+
+
+ // Convenience wrapper for option parser that specifies the help option
+ struct Help : Opt {
+ Help(bool& showHelpFlag);
+ };
+
+ // Result type for parser operation
+ using Detail::ParserResult;
+
+ namespace Detail {
+ template <typename DerivedT>
+ template <typename T>
+ Parser
+ ComposableParserImpl<DerivedT>::operator|(T const& other) const {
+ return Parser() | static_cast<DerivedT const&>(*this) | other;
+ }
+ }
+
+ } // namespace Clara
+} // namespace Catch
+
+#if defined( __clang__ )
+# pragma clang diagnostic pop
+#endif
+
+#if defined( __GNUC__ )
+# pragma GCC diagnostic pop
+#endif
+
+#endif // CATCH_CLARA_HPP_INCLUDED
+
+namespace Catch {
+
+ struct ConfigData;
+
+ Clara::Parser makeCommandLineParser( ConfigData& config );
+
+} // end namespace Catch
+
+#endif // CATCH_COMMANDLINE_HPP_INCLUDED
+
+namespace Catch {
+
+ class Session : Detail::NonCopyable {
+ public:
+
+ Session();
+ ~Session();
+
+ void showHelp() const;
+ void libIdentify();
+
+ int applyCommandLine( int argc, char const * const * argv );
+ #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+ int applyCommandLine( int argc, wchar_t const * const * argv );
+ #endif
+
+ void useConfigData( ConfigData const& configData );
+
+ template<typename CharT>
+ int run(int argc, CharT const * const argv[]) {
+ if (m_startupExceptions)
+ return 1;
+ int returnCode = applyCommandLine(argc, argv);
+ if (returnCode == 0)
+ returnCode = run();
+ return returnCode;
+ }
+
+ int run();
+
+ Clara::Parser const& cli() const;
+ void cli( Clara::Parser const& newParser );
+ ConfigData& configData();
+ Config& config();
+ private:
+ int runInternal();
+
+ Clara::Parser m_cli;
+ ConfigData m_configData;
+ Detail::unique_ptr<Config> m_config;
+ bool m_startupExceptions = false;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_SESSION_HPP_INCLUDED
+
+
+#ifndef CATCH_TAG_ALIAS_HPP_INCLUDED
+#define CATCH_TAG_ALIAS_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+ struct TagAlias {
+ TagAlias(std::string const& _tag, SourceLineInfo _lineInfo):
+ tag(_tag),
+ lineInfo(_lineInfo)
+ {}
+
+ std::string tag;
+ SourceLineInfo lineInfo;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_TAG_ALIAS_HPP_INCLUDED
+
+
+#ifndef CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+#define CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+
+
+namespace Catch {
+
+ struct RegistrarForTagAliases {
+ RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+ };
+
+} // end namespace Catch
+
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#endif // CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+
+
+#ifndef CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+#define CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+
+// We need this suppression to leak, because it took until GCC 10
+// for the front end to handle local suppression via _Pragma properly
+// inside templates (so `TEMPLATE_TEST_CASE` and co).
+// **THIS IS DIFFERENT FOR STANDARD TESTS, WHERE GCC 9 IS SUFFICIENT**
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ < 10
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+
+
+
+#ifndef CATCH_TEST_MACROS_HPP_INCLUDED
+#define CATCH_TEST_MACROS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+#define CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+#define CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+
+
+
+#ifndef CATCH_DECOMPOSER_HPP_INCLUDED
+#define CATCH_DECOMPOSER_HPP_INCLUDED
+
+
+
+#ifndef CATCH_COMPARE_TRAITS_HPP_INCLUDED
+#define CATCH_COMPARE_TRAITS_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+ namespace Detail {
+
+#if defined( __GNUC__ ) && !defined( __clang__ )
+# pragma GCC diagnostic push
+ // GCC likes to complain about comparing bool with 0, in the decltype()
+ // that defines the comparable traits below.
+# pragma GCC diagnostic ignored "-Wbool-compare"
+ // "ordered comparison of pointer with integer zero" same as above,
+ // but it does not have a separate warning flag to suppress
+# pragma GCC diagnostic ignored "-Wextra"
+ // Did you know that comparing floats with `0` directly
+ // is super-duper dangerous in unevaluated context?
+# pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+#if defined( __clang__ )
+# pragma clang diagnostic push
+ // Did you know that comparing floats with `0` directly
+ // is super-duper dangerous in unevaluated context?
+# pragma clang diagnostic ignored "-Wfloat-equal"
+#endif
+
+#define CATCH_DEFINE_COMPARABLE_TRAIT( id, op ) \
+ template <typename, typename, typename = void> \
+ struct is_##id##_comparable : std::false_type {}; \
+ template <typename T, typename U> \
+ struct is_##id##_comparable< \
+ T, \
+ U, \
+ void_t<decltype( std::declval<T>() op std::declval<U>() )>> \
+ : std::true_type {}; \
+ template <typename, typename = void> \
+ struct is_##id##_0_comparable : std::false_type {}; \
+ template <typename T> \
+ struct is_##id##_0_comparable<T, \
+ void_t<decltype( std::declval<T>() op 0 )>> \
+ : std::true_type {};
+
+ // We need all 6 pre-spaceship comparison ops: <, <=, >, >=, ==, !=
+ CATCH_DEFINE_COMPARABLE_TRAIT( lt, < )
+ CATCH_DEFINE_COMPARABLE_TRAIT( le, <= )
+ CATCH_DEFINE_COMPARABLE_TRAIT( gt, > )
+ CATCH_DEFINE_COMPARABLE_TRAIT( ge, >= )
+ CATCH_DEFINE_COMPARABLE_TRAIT( eq, == )
+ CATCH_DEFINE_COMPARABLE_TRAIT( ne, != )
+
+#undef CATCH_DEFINE_COMPARABLE_TRAIT
+
+#if defined( __GNUC__ ) && !defined( __clang__ )
+# pragma GCC diagnostic pop
+#endif
+#if defined( __clang__ )
+# pragma clang diagnostic pop
+#endif
+
+
+ } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_COMPARE_TRAITS_HPP_INCLUDED
+
+
+#ifndef CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+#define CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace Catch {
+namespace Detail {
+
+#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510
+
+ using std::conjunction;
+ using std::disjunction;
+ using std::negation;
+
+#else
+
+ template <class...> struct conjunction : std::true_type {};
+ template <class B1> struct conjunction<B1> : B1 {};
+ template <class B1, class... Bn>
+ struct conjunction<B1, Bn...>
+ : std::conditional_t<bool( B1::value ), conjunction<Bn...>, B1> {};
+
+ template <class...> struct disjunction : std::false_type {};
+ template <class B1> struct disjunction<B1> : B1 {};
+ template <class B1, class... Bn>
+ struct disjunction<B1, Bn...>
+ : std::conditional_t<bool( B1::value ), B1, disjunction<Bn...>> {};
+
+ template <class B>
+ struct negation : std::integral_constant<bool, !bool(B::value)> {};
+
+#endif
+
+} // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+
+#include <type_traits>
+#include <iosfwd>
+
+/** \file
+ * Why does decomposing look the way it does:
+ *
+ * Conceptually, decomposing is simple. We change `REQUIRE( a == b )` into
+ * `Decomposer{} <= a == b`, so that `Decomposer{} <= a` is evaluated first,
+ * and our custom operator is used for `a == b`, because `a` is transformed
+ * into `ExprLhs<T&>` and then into `BinaryExpr<T&, U&>`.
+ *
+ * In practice, decomposing ends up a mess, because we have to support
+ * various fun things.
+ *
+ * 1) Types that are only comparable with literal 0, and they do this by
+ * comparing against a magic type with pointer constructor and deleted
+ * other constructors. Example: `REQUIRE((a <=> b) == 0)` in libstdc++
+ *
+ * 2) Types that are only comparable with literal 0, and they do this by
+ * comparing against a magic type with consteval integer constructor.
+ * Example: `REQUIRE((a <=> b) == 0)` in current MSVC STL.
+ *
+ * 3) Types that have no linkage, and so we cannot form a reference to
+ * them. Example: some implementations of traits.
+ *
+ * 4) Starting with C++20, when the compiler sees `a == b`, it also uses
+ * `b == a` when constructing the overload set. For us this means that
+ * when the compiler handles `ExprLhs<T> == b`, it also tries to resolve
+ * the overload set for `b == ExprLhs<T>`.
+ *
+ * To accomodate these use cases, decomposer ended up rather complex.
+ *
+ * 1) These types are handled by adding SFINAE overloads to our comparison
+ * operators, checking whether `T == U` are comparable with the given
+ * operator, and if not, whether T (or U) are comparable with literal 0.
+ * If yes, the overload compares T (or U) with 0 literal inline in the
+ * definition.
+ *
+ * Note that for extra correctness, we check that the other type is
+ * either an `int` (literal 0 is captured as `int` by templates), or
+ * a `long` (some platforms use 0L for `NULL` and we want to support
+ * that for pointer comparisons).
+ *
+ * 2) For these types, `is_foo_comparable<T, int>` is true, but letting
+ * them fall into the overload that actually does `T == int` causes
+ * compilation error. Handling them requires that the decomposition
+ * is `constexpr`, so that P2564R3 applies and the `consteval` from
+ * their accompanying magic type is propagated through the `constexpr`
+ * call stack.
+ *
+ * However this is not enough to handle these types automatically,
+ * because our default is to capture types by reference, to avoid
+ * runtime copies. While these references cannot become dangling,
+ * they outlive the constexpr context and thus the default capture
+ * path cannot be actually constexpr.
+ *
+ * The solution is to capture these types by value, by explicitly
+ * specializing `Catch::capture_by_value` for them. Catch2 provides
+ * specialization for `std::foo_ordering`s, but users can specialize
+ * the trait for their own types as well.
+ *
+ * 3) If a type has no linkage, we also cannot capture it by reference.
+ * The solution is once again to capture them by value. We handle
+ * the common cases by using `std::is_arithmetic` as the default
+ * for `Catch::capture_by_value`, but that is only a some-effort
+ * heuristic. But as with 2), users can specialize `capture_by_value`
+ * for their own types as needed.
+ *
+ * 4) To support C++20 and make the SFINAE on our decomposing operators
+ * work, the SFINAE has to happen in return type, rather than in
+ * a template type. This is due to our use of logical type traits
+ * (`conjunction`/`disjunction`/`negation`), that we use to workaround
+ * an issue in older (9-) versions of GCC. I still blame C++20 for
+ * this, because without the comparison order switching, the logical
+ * traits could still be used in template type.
+ *
+ * There are also other side concerns, e.g. supporting both `REQUIRE(a)`
+ * and `REQUIRE(a == b)`, or making `REQUIRE_THAT(a, IsEqual(b))` slot
+ * nicely into the same expression handling logic, but these are rather
+ * straightforward and add only a bit of complexity (e.g. common base
+ * class for decomposed expressions).
+ */
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable:4018) // more "signed/unsigned mismatch"
+#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+#pragma warning(disable:4180) // qualifier applied to function type has no meaning
+#pragma warning(disable:4800) // Forcing result to true or false
+#endif
+
+#ifdef __clang__
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wsign-compare"
+# pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#elif defined __GNUC__
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wsign-compare"
+# pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+#if defined(CATCH_CPP20_OR_GREATER) && __has_include(<compare>)
+# include <compare>
+# if defined( __cpp_lib_three_way_comparison ) && \
+ __cpp_lib_three_way_comparison >= 201907L
+# define CATCH_CONFIG_CPP20_COMPARE_OVERLOADS
+# endif
+#endif
+
+namespace Catch {
+
+ namespace Detail {
+ // This was added in C++20, but we require only C++14 for now.
+ template <typename T>
+ using RemoveCVRef_t = std::remove_cv_t<std::remove_reference_t<T>>;
+ }
+
+ // Note: There is nothing that stops us from extending this,
+ // e.g. to `std::is_scalar`, but the more encompassing
+ // traits are usually also more expensive. For now we
+ // keep this as it used to be and it can be changed later.
+ template <typename T>
+ struct capture_by_value
+ : std::integral_constant<bool, std::is_arithmetic<T>{}> {};
+
+#if defined( CATCH_CONFIG_CPP20_COMPARE_OVERLOADS )
+ template <>
+ struct capture_by_value<std::strong_ordering> : std::true_type {};
+ template <>
+ struct capture_by_value<std::weak_ordering> : std::true_type {};
+ template <>
+ struct capture_by_value<std::partial_ordering> : std::true_type {};
+#endif
+
+ template <typename T>
+ struct always_false : std::false_type {};
+
+ class ITransientExpression {
+ bool m_isBinaryExpression;
+ bool m_result;
+
+ public:
+ constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
+ constexpr auto getResult() const -> bool { return m_result; }
+ //! This function **has** to be overriden by the derived class.
+ virtual void streamReconstructedExpression( std::ostream& os ) const;
+
+ constexpr ITransientExpression( bool isBinaryExpression, bool result )
+ : m_isBinaryExpression( isBinaryExpression ),
+ m_result( result )
+ {}
+
+ ITransientExpression() = default;
+ ITransientExpression(ITransientExpression const&) = default;
+ ITransientExpression& operator=(ITransientExpression const&) = default;
+
+ friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) {
+ expr.streamReconstructedExpression(out);
+ return out;
+ }
+
+ protected:
+ ~ITransientExpression() = default;
+ };
+
+ void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
+
+ template<typename LhsT, typename RhsT>
+ class BinaryExpr : public ITransientExpression {
+ LhsT m_lhs;
+ StringRef m_op;
+ RhsT m_rhs;
+
+ void streamReconstructedExpression( std::ostream &os ) const override {
+ formatReconstructedExpression
+ ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
+ }
+
+ public:
+ constexpr BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+ : ITransientExpression{ true, comparisonResult },
+ m_lhs( lhs ),
+ m_op( op ),
+ m_rhs( rhs )
+ {}
+
+ template<typename T>
+ auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+ static_assert(always_false<T>::value,
+ "chained comparisons are not supported inside assertions, "
+ "wrap the expression inside parentheses, or decompose it");
+ }
+
+ template<typename T>
+ auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+ static_assert(always_false<T>::value,
+ "chained comparisons are not supported inside assertions, "
+ "wrap the expression inside parentheses, or decompose it");
+ }
+
+ template<typename T>
+ auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+ static_assert(always_false<T>::value,
+ "chained comparisons are not supported inside assertions, "
+ "wrap the expression inside parentheses, or decompose it");
+ }
+
+ template<typename T>
+ auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+ static_assert(always_false<T>::value,
+ "chained comparisons are not supported inside assertions, "
+ "wrap the expression inside parentheses, or decompose it");
+ }
+
+ template<typename T>
+ auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+ static_assert(always_false<T>::value,
+ "chained comparisons are not supported inside assertions, "
+ "wrap the expression inside parentheses, or decompose it");
+ }
+
+ template<typename T>
+ auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+ static_assert(always_false<T>::value,
+ "chained comparisons are not supported inside assertions, "
+ "wrap the expression inside parentheses, or decompose it");
+ }
+
+ template<typename T>
+ auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+ static_assert(always_false<T>::value,
+ "chained comparisons are not supported inside assertions, "
+ "wrap the expression inside parentheses, or decompose it");
+ }
+
+ template<typename T>
+ auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+ static_assert(always_false<T>::value,
+ "chained comparisons are not supported inside assertions, "
+ "wrap the expression inside parentheses, or decompose it");
+ }
+ };
+
+ template<typename LhsT>
+ class UnaryExpr : public ITransientExpression {
+ LhsT m_lhs;
+
+ void streamReconstructedExpression( std::ostream &os ) const override {
+ os << Catch::Detail::stringify( m_lhs );
+ }
+
+ public:
+ explicit constexpr UnaryExpr( LhsT lhs )
+ : ITransientExpression{ false, static_cast<bool>(lhs) },
+ m_lhs( lhs )
+ {}
+ };
+
+
+ template<typename LhsT>
+ class ExprLhs {
+ LhsT m_lhs;
+ public:
+ explicit constexpr ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
+
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( id, op ) \
+ template <typename RhsT> \
+ constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+ -> std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ Detail::negation<capture_by_value< \
+ Detail::RemoveCVRef_t<RhsT>>>>::value, \
+ BinaryExpr<LhsT, RhsT const&>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ -> std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ capture_by_value<RhsT>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ -> std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_eq_0_comparable<LhsT>, \
+ /* We allow long because we want `ptr op NULL` to be accepted */ \
+ Detail::disjunction<std::is_same<RhsT, int>, \
+ std::is_same<RhsT, long>>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( rhs != 0 ) { throw_test_failure_exception(); } \
+ return { \
+ static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ -> std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_eq_0_comparable<RhsT>, \
+ /* We allow long because we want `ptr op NULL` to be accepted */ \
+ Detail::disjunction<std::is_same<LhsT, int>, \
+ std::is_same<LhsT, long>>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \
+ return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ }
+
+ CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( eq, == )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( ne, != )
+
+ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR
+
+
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( id, op ) \
+ template <typename RhsT> \
+ constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+ -> std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ Detail::negation<capture_by_value< \
+ Detail::RemoveCVRef_t<RhsT>>>>::value, \
+ BinaryExpr<LhsT, RhsT const&>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ -> std::enable_if_t< \
+ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+ capture_by_value<RhsT>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ -> std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_##id##_0_comparable<LhsT>, \
+ std::is_same<RhsT, int>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( rhs != 0 ) { throw_test_failure_exception(); } \
+ return { \
+ static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ -> std::enable_if_t< \
+ Detail::conjunction< \
+ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+ Detail::is_##id##_0_comparable<RhsT>, \
+ std::is_same<LhsT, int>>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \
+ return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ }
+
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( lt, < )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( le, <= )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( gt, > )
+ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( ge, >= )
+
+ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR
+
+
+#define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR( op ) \
+ template <typename RhsT> \
+ constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+ -> std::enable_if_t< \
+ !capture_by_value<Detail::RemoveCVRef_t<RhsT>>::value, \
+ BinaryExpr<LhsT, RhsT const&>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ } \
+ template <typename RhsT> \
+ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+ -> std::enable_if_t<capture_by_value<RhsT>::value, \
+ BinaryExpr<LhsT, RhsT>> { \
+ return { \
+ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+ }
+
+ CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|)
+ CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(&)
+ CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(^)
+
+ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR
+
+ template<typename RhsT>
+ friend auto operator && ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
+ static_assert(always_false<RhsT>::value,
+ "operator&& is not supported inside assertions, "
+ "wrap the expression inside parentheses, or decompose it");
+ }
+
+ template<typename RhsT>
+ friend auto operator || ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
+ static_assert(always_false<RhsT>::value,
+ "operator|| is not supported inside assertions, "
+ "wrap the expression inside parentheses, or decompose it");
+ }
+
+ constexpr auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
+ return UnaryExpr<LhsT>{ m_lhs };
+ }
+ };
+
+ struct Decomposer {
+ template <typename T,
+ std::enable_if_t<!capture_by_value<Detail::RemoveCVRef_t<T>>::value,
+ int> = 0>
+ constexpr friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs<T const&> {
+ return ExprLhs<const T&>{ lhs };
+ }
+
+ template <typename T,
+ std::enable_if_t<capture_by_value<T>::value, int> = 0>
+ constexpr friend auto operator <= ( Decomposer &&, T value ) -> ExprLhs<T> {
+ return ExprLhs<T>{ value };
+ }
+ };
+
+} // end namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+#ifdef __clang__
+# pragma clang diagnostic pop
+#elif defined __GNUC__
+# pragma GCC diagnostic pop
+#endif
+
+#endif // CATCH_DECOMPOSER_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+ struct AssertionReaction {
+ bool shouldDebugBreak = false;
+ bool shouldThrow = false;
+ bool shouldSkip = false;
+ };
+
+ class AssertionHandler {
+ AssertionInfo m_assertionInfo;
+ AssertionReaction m_reaction;
+ bool m_completed = false;
+ IResultCapture& m_resultCapture;
+
+ public:
+ AssertionHandler
+ ( StringRef macroName,
+ SourceLineInfo const& lineInfo,
+ StringRef capturedExpression,
+ ResultDisposition::Flags resultDisposition );
+ ~AssertionHandler() {
+ if ( !m_completed ) {
+ m_resultCapture.handleIncomplete( m_assertionInfo );
+ }
+ }
+
+
+ template<typename T>
+ void handleExpr( ExprLhs<T> const& expr ) {
+ handleExpr( expr.makeUnaryExpr() );
+ }
+ void handleExpr( ITransientExpression const& expr );
+
+ void handleMessage(ResultWas::OfType resultType, StringRef message);
+
+ void handleExceptionThrownAsExpected();
+ void handleUnexpectedExceptionNotThrown();
+ void handleExceptionNotThrownAsExpected();
+ void handleThrowingCallSkipped();
+ void handleUnexpectedInflightException();
+
+ void complete();
+
+ // query
+ auto allowThrows() const -> bool;
+ };
+
+ void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str );
+
+} // namespace Catch
+
+#endif // CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+
+
+#ifndef CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
+#define CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
+
+
+#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+ #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__##_catch_sr
+#else
+ #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"_catch_sr
+#endif
+
+#endif // CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
+
+// We need this suppression to leak, because it took until GCC 10
+// for the front end to handle local suppression via _Pragma properly
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ <= 9
+ #pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+#if !defined(CATCH_CONFIG_DISABLE)
+
+#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+
+///////////////////////////////////////////////////////////////////////////////
+// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
+// macros.
+#define INTERNAL_CATCH_TRY
+#define INTERNAL_CATCH_CATCH( capturer )
+
+#else // CATCH_CONFIG_FAST_COMPILE
+
+#define INTERNAL_CATCH_TRY try
+#define INTERNAL_CATCH_CATCH( handler ) catch(...) { (handler).handleUnexpectedInflightException(); }
+
+#endif
+
+#define INTERNAL_CATCH_REACT( handler ) handler.complete();
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
+ do { /* NOLINT(bugprone-infinite-loop) */ \
+ /* The expression should not be evaluated, but warnings should hopefully be checked */ \
+ CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
+ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+ INTERNAL_CATCH_TRY { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+ catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); /* NOLINT(bugprone-chained-comparison) */ \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+ } while( (void)0, (false) && static_cast<const bool&>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
+ // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
+ INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+ if( Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
+ INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+ if( !Catch::getResultCapture().lastAssertionPassed() )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
+ do { \
+ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+ try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+ static_cast<void>(__VA_ARGS__); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
+ } \
+ catch( ... ) { \
+ catchAssertionHandler.handleUnexpectedInflightException(); \
+ } \
+ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+ } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
+ do { \
+ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
+ if( catchAssertionHandler.allowThrows() ) \
+ try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+ static_cast<void>(__VA_ARGS__); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+ } \
+ catch( ... ) { \
+ catchAssertionHandler.handleExceptionThrownAsExpected(); \
+ } \
+ else \
+ catchAssertionHandler.handleThrowingCallSkipped(); \
+ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+ } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
+ do { \
+ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+ if( catchAssertionHandler.allowThrows() ) \
+ try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+ static_cast<void>(expr); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+ } \
+ catch( exceptionType const& ) { \
+ catchAssertionHandler.handleExceptionThrownAsExpected(); \
+ } \
+ catch( ... ) { \
+ catchAssertionHandler.handleUnexpectedInflightException(); \
+ } \
+ else \
+ catchAssertionHandler.handleThrowingCallSkipped(); \
+ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+ } while( false )
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Although this is matcher-based, it can be used with just a string
+#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
+ do { \
+ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+ if( catchAssertionHandler.allowThrows() ) \
+ try { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+ static_cast<void>(__VA_ARGS__); \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+ } \
+ catch( ... ) { \
+ Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher ); \
+ } \
+ else \
+ catchAssertionHandler.handleThrowingCallSkipped(); \
+ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+ } while( false )
+
+#endif // CATCH_CONFIG_DISABLE
+
+#endif // CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+
+
+#ifndef CATCH_SECTION_HPP_INCLUDED
+#define CATCH_SECTION_HPP_INCLUDED
+
+
+
+
+/** \file
+ * Wrapper for the STATIC_ANALYSIS_SUPPORT configuration option
+ *
+ * Some of Catch2's macros can be defined differently to work better with
+ * static analysis tools, like clang-tidy or coverity.
+ * Currently the main use case is to show that `SECTION`s are executed
+ * exclusively, and not all in one run of a `TEST_CASE`.
+ */
+
+#ifndef CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
+#define CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
+
+
+#if defined(__clang_analyzer__) || defined(__COVERITY__)
+ #define CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT
+#endif
+
+#if defined( CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT ) && \
+ !defined( CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) && \
+ !defined( CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT )
+# define CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+#endif
+
+
+#endif // CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
+
+
+#ifndef CATCH_TIMER_HPP_INCLUDED
+#define CATCH_TIMER_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+ class Timer {
+ uint64_t m_nanoseconds = 0;
+ public:
+ void start();
+ auto getElapsedNanoseconds() const -> uint64_t;
+ auto getElapsedMicroseconds() const -> uint64_t;
+ auto getElapsedMilliseconds() const -> unsigned int;
+ auto getElapsedSeconds() const -> double;
+ };
+
+} // namespace Catch
+
+#endif // CATCH_TIMER_HPP_INCLUDED
+
+namespace Catch {
+
+ class Section : Detail::NonCopyable {
+ public:
+ Section( SectionInfo&& info );
+ Section( SourceLineInfo const& _lineInfo,
+ StringRef _name,
+ const char* const = nullptr );
+ ~Section();
+
+ // This indicates whether the section should be executed or not
+ explicit operator bool() const;
+
+ private:
+ SectionInfo m_info;
+
+ Counts m_assertions;
+ bool m_sectionIncluded;
+ Timer m_timer;
+ };
+
+} // end namespace Catch
+
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
+# define INTERNAL_CATCH_SECTION( ... ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( \
+ catch_internal_Section ) = \
+ Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+# define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( \
+ catch_internal_Section ) = \
+ Catch::SectionInfo( \
+ CATCH_INTERNAL_LINEINFO, \
+ ( Catch::ReusableStringStream() << __VA_ARGS__ ) \
+ .str() ) ) \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#else
+
+// These section definitions imply that at most one section at one level
+// will be intered (because only one section's __LINE__ can be equal to
+// the dummy `catchInternalSectionHint` variable from `TEST_CASE`).
+
+namespace Catch {
+ namespace Detail {
+ // Intentionally without linkage, as it should only be used as a dummy
+ // symbol for static analysis.
+ // The arguments are used as a dummy for checking warnings in the passed
+ // expressions.
+ int GetNewSectionHint( StringRef, const char* const = nullptr );
+ } // namespace Detail
+} // namespace Catch
+
+
+# define INTERNAL_CATCH_SECTION( ... ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+ if ( [[maybe_unused]] const int catchInternalPreviousSectionHint = \
+ catchInternalSectionHint, \
+ catchInternalSectionHint = \
+ Catch::Detail::GetNewSectionHint(__VA_ARGS__); \
+ catchInternalPreviousSectionHint == __LINE__ ) \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+# define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+ if ( [[maybe_unused]] const int catchInternalPreviousSectionHint = \
+ catchInternalSectionHint, \
+ catchInternalSectionHint = Catch::Detail::GetNewSectionHint( \
+ ( Catch::ReusableStringStream() << __VA_ARGS__ ).str()); \
+ catchInternalPreviousSectionHint == __LINE__ ) \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#endif
+
+
+#endif // CATCH_SECTION_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_REGISTRY_HPP_INCLUDED
+#define CATCH_TEST_REGISTRY_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
+#define CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
+
+namespace Catch {
+
+ class ITestInvoker {
+ public:
+ virtual void invoke() const = 0;
+ virtual ~ITestInvoker(); // = default
+ };
+
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
+
+
+#ifndef CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+#define CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+
+#define INTERNAL_CATCH_EXPAND1( param ) INTERNAL_CATCH_EXPAND2( param )
+#define INTERNAL_CATCH_EXPAND2( ... ) INTERNAL_CATCH_NO##__VA_ARGS__
+#define INTERNAL_CATCH_DEF( ... ) INTERNAL_CATCH_DEF __VA_ARGS__
+#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+
+#define INTERNAL_CATCH_REMOVE_PARENS( ... ) \
+ INTERNAL_CATCH_EXPAND1( INTERNAL_CATCH_DEF __VA_ARGS__ )
+
+#endif // CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+
+// GCC 5 and older do not properly handle disabling unused-variable warning
+// with a _Pragma. This means that we have to leak the suppression to the
+// user code as well :-(
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+
+
+namespace Catch {
+
+template<typename C>
+class TestInvokerAsMethod : public ITestInvoker {
+ void (C::*m_testAsMethod)();
+public:
+ TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
+
+ void invoke() const override {
+ C obj;
+ (obj.*m_testAsMethod)();
+ }
+};
+
+Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() );
+
+template<typename C>
+Detail::unique_ptr<ITestInvoker> makeTestInvoker( void (C::*testAsMethod)() ) {
+ return Detail::make_unique<TestInvokerAsMethod<C>>( testAsMethod );
+}
+
+struct NameAndTags {
+ constexpr NameAndTags( StringRef name_ = StringRef(),
+ StringRef tags_ = StringRef() ) noexcept:
+ name( name_ ), tags( tags_ ) {}
+ StringRef name;
+ StringRef tags;
+};
+
+struct AutoReg : Detail::NonCopyable {
+ AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept;
+};
+
+} // end namespace Catch
+
+#if defined(CATCH_CONFIG_DISABLE)
+ #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
+ static inline void TestName()
+ #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
+ namespace{ \
+ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+ void test(); \
+ }; \
+ } \
+ void TestName::test()
+#endif
+
+
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
+
+ ///////////////////////////////////////////////////////////////////////////////
+ #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
+ static void TestName(); \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ namespace{ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ static void TestName()
+ #define INTERNAL_CATCH_TESTCASE( ... ) \
+ INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__ )
+
+#else // ^^ !CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT | vv CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+
+
+// Dummy registrator for the dumy test case macros
+namespace Catch {
+ namespace Detail {
+ struct DummyUse {
+ DummyUse( void ( * )( int ), Catch::NameAndTags const& );
+ };
+ } // namespace Detail
+} // namespace Catch
+
+// Note that both the presence of the argument and its exact name are
+// necessary for the section support.
+
+// We provide a shadowed variable so that a `SECTION` inside non-`TEST_CASE`
+// tests can compile. The redefined `TEST_CASE` shadows this with param.
+static int catchInternalSectionHint = 0;
+
+# define INTERNAL_CATCH_TESTCASE2( fname, ... ) \
+ static void fname( int ); \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ static const Catch::Detail::DummyUse INTERNAL_CATCH_UNIQUE_NAME( \
+ dummyUser )( &(fname), Catch::NameAndTags{ __VA_ARGS__ } ); \
+ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+ static void fname( [[maybe_unused]] int catchInternalSectionHint ) \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+# define INTERNAL_CATCH_TESTCASE( ... ) \
+ INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( dummyFunction ), __VA_ARGS__ )
+
+
+#endif // CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+
+ ///////////////////////////////////////////////////////////////////////////////
+ #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ namespace{ \
+ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+ void test(); \
+ }; \
+ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+ Catch::makeTestInvoker( &TestName::test ), \
+ CATCH_INTERNAL_LINEINFO, \
+ #ClassName##_catch_sr, \
+ Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+ } \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ void TestName::test()
+ #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
+ INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
+
+
+ ///////////////////////////////////////////////////////////////////////////////
+ #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ namespace { \
+ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+ Catch::makeTestInvoker( &QualifiedMethod ), \
+ CATCH_INTERNAL_LINEINFO, \
+ "&" #QualifiedMethod##_catch_sr, \
+ Catch::NameAndTags{ __VA_ARGS__ } ); \
+ } /* NOLINT */ \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+
+ ///////////////////////////////////////////////////////////////////////////////
+ #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+ do { \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ } while(false)
+
+
+#endif // CATCH_TEST_REGISTRY_HPP_INCLUDED
+
+
+// All of our user-facing macros support configuration toggle, that
+// forces them to be defined prefixed with CATCH_. We also like to
+// support another toggle that can minimize (disable) their implementation.
+// Given this, we have 4 different configuration options below
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+ #define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+ #define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+ #define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+ #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+ #define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+ #define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+ #define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+ #define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+ #define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+ #define CATCH_CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+ #define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+ #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+ #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+ #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+ #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+ #define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+ #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+ #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define CATCH_SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+
+ #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+ #define CATCH_STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__ , #__VA_ARGS__ ); CATCH_SUCCEED( #__VA_ARGS__ )
+ #define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+ #define CATCH_STATIC_CHECK( ... ) static_assert( __VA_ARGS__ , #__VA_ARGS__ ); CATCH_SUCCEED( #__VA_ARGS__ )
+ #define CATCH_STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+ #else
+ #define CATCH_STATIC_REQUIRE( ... ) CATCH_REQUIRE( __VA_ARGS__ )
+ #define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
+ #define CATCH_STATIC_CHECK( ... ) CATCH_CHECK( __VA_ARGS__ )
+ #define CATCH_STATIC_CHECK_FALSE( ... ) CATCH_CHECK_FALSE( __VA_ARGS__ )
+ #endif
+
+
+ // "BDD-style" convenience wrappers
+ #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+ #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+ #define CATCH_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc )
+ #define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+ #define CATCH_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc )
+ #define CATCH_AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+ #define CATCH_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc )
+ #define CATCH_AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc )
+
+#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, implemented | vv prefixed, disabled
+
+ #define CATCH_REQUIRE( ... ) (void)(0)
+ #define CATCH_REQUIRE_FALSE( ... ) (void)(0)
+
+ #define CATCH_REQUIRE_THROWS( ... ) (void)(0)
+ #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+ #define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
+
+ #define CATCH_CHECK( ... ) (void)(0)
+ #define CATCH_CHECK_FALSE( ... ) (void)(0)
+ #define CATCH_CHECKED_IF( ... ) if (__VA_ARGS__)
+ #define CATCH_CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
+ #define CATCH_CHECK_NOFAIL( ... ) (void)(0)
+
+ #define CATCH_CHECK_THROWS( ... ) (void)(0)
+ #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+ #define CATCH_CHECK_NOTHROW( ... ) (void)(0)
+
+ #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+ #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+ #define CATCH_METHOD_AS_TEST_CASE( method, ... )
+ #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
+ #define CATCH_SECTION( ... )
+ #define CATCH_DYNAMIC_SECTION( ... )
+ #define CATCH_FAIL( ... ) (void)(0)
+ #define CATCH_FAIL_CHECK( ... ) (void)(0)
+ #define CATCH_SUCCEED( ... ) (void)(0)
+ #define CATCH_SKIP( ... ) (void)(0)
+
+ #define CATCH_STATIC_REQUIRE( ... ) (void)(0)
+ #define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+ #define CATCH_STATIC_CHECK( ... ) (void)(0)
+ #define CATCH_STATIC_CHECK_FALSE( ... ) (void)(0)
+
+ // "BDD-style" convenience wrappers
+ #define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+ #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
+ #define CATCH_GIVEN( desc )
+ #define CATCH_AND_GIVEN( desc )
+ #define CATCH_WHEN( desc )
+ #define CATCH_AND_WHEN( desc )
+ #define CATCH_THEN( desc )
+ #define CATCH_AND_THEN( desc )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, disabled | vv unprefixed, implemented
+
+ #define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+ #define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+
+ #define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+ #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+ #define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+ #define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+ #define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+ #define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+ #define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+
+ #define CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+ #define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+ #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+ #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+ #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+ #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+ #define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+ #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+ #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+ #define SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+
+
+ #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+ #define STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__, #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+ #define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+ #define STATIC_CHECK( ... ) static_assert( __VA_ARGS__, #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+ #define STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+ #else
+ #define STATIC_REQUIRE( ... ) REQUIRE( __VA_ARGS__ )
+ #define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
+ #define STATIC_CHECK( ... ) CHECK( __VA_ARGS__ )
+ #define STATIC_CHECK_FALSE( ... ) CHECK_FALSE( __VA_ARGS__ )
+ #endif
+
+ // "BDD-style" convenience wrappers
+ #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+ #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+ #define GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc )
+ #define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+ #define WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc )
+ #define AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+ #define THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc )
+ #define AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ unprefixed, implemented | vv unprefixed, disabled
+
+ #define REQUIRE( ... ) (void)(0)
+ #define REQUIRE_FALSE( ... ) (void)(0)
+
+ #define REQUIRE_THROWS( ... ) (void)(0)
+ #define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+ #define REQUIRE_NOTHROW( ... ) (void)(0)
+
+ #define CHECK( ... ) (void)(0)
+ #define CHECK_FALSE( ... ) (void)(0)
+ #define CHECKED_IF( ... ) if (__VA_ARGS__)
+ #define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
+ #define CHECK_NOFAIL( ... ) (void)(0)
+
+ #define CHECK_THROWS( ... ) (void)(0)
+ #define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+ #define CHECK_NOTHROW( ... ) (void)(0)
+
+ #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
+ #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+ #define METHOD_AS_TEST_CASE( method, ... )
+ #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
+ #define SECTION( ... )
+ #define DYNAMIC_SECTION( ... )
+ #define FAIL( ... ) (void)(0)
+ #define FAIL_CHECK( ... ) (void)(0)
+ #define SUCCEED( ... ) (void)(0)
+ #define SKIP( ... ) (void)(0)
+
+ #define STATIC_REQUIRE( ... ) (void)(0)
+ #define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+ #define STATIC_CHECK( ... ) (void)(0)
+ #define STATIC_CHECK_FALSE( ... ) (void)(0)
+
+ // "BDD-style" convenience wrappers
+ #define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ) )
+ #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
+
+ #define GIVEN( desc )
+ #define AND_GIVEN( desc )
+ #define WHEN( desc )
+ #define AND_WHEN( desc )
+ #define THEN( desc )
+ #define AND_THEN( desc )
+
+#endif // ^^ unprefixed, disabled
+
+// end of user facing macros
+
+#endif // CATCH_TEST_MACROS_HPP_INCLUDED
+
+
+#ifndef CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+#define CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+
+
+
+#ifndef CATCH_PREPROCESSOR_HPP_INCLUDED
+#define CATCH_PREPROCESSOR_HPP_INCLUDED
+
+
+#if defined(__GNUC__)
+// We need to silence "empty __VA_ARGS__ warning", and using just _Pragma does not work
+#pragma GCC system_header
+#endif
+
+
+#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
+#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
+
+#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
+// MSVC needs more evaluations
+#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
+#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
+#else
+#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__)
+#endif
+
+#define CATCH_REC_END(...)
+#define CATCH_REC_OUT
+
+#define CATCH_EMPTY()
+#define CATCH_DEFER(id) id CATCH_EMPTY()
+
+#define CATCH_REC_GET_END2() 0, CATCH_REC_END
+#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
+#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
+#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
+#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
+#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
+
+#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+
+#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+
+// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
+// and passes userdata as the first parameter to each invocation,
+// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
+#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+#else
+// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
+#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+#endif
+
+#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
+#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#else
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#endif
+
+#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
+ CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+
+#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
+#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
+#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+
+#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+
+#define INTERNAL_CATCH_TYPE_GEN\
+ template<typename...> struct TypeList {};\
+ template<typename...Ts>\
+ constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
+ template<template<typename...> class...> struct TemplateTypeList{};\
+ template<template<typename...> class...Cs>\
+ constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
+ template<typename...>\
+ struct append;\
+ template<typename...>\
+ struct rewrap;\
+ template<template<typename...> class, typename...>\
+ struct create;\
+ template<template<typename...> class, typename>\
+ struct convert;\
+ \
+ template<typename T> \
+ struct append<T> { using type = T; };\
+ template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
+ struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
+ template< template<typename...> class L1, typename...E1, typename...Rest>\
+ struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
+ \
+ template< template<typename...> class Container, template<typename...> class List, typename...elems>\
+ struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
+ template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
+ struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
+ \
+ template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
+ struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
+ template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
+ struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
+
+#define INTERNAL_CATCH_NTTP_1(signature, ...)\
+ template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
+ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+ constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
+ template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
+ template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
+ constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
+ \
+ template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+ struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
+ template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
+ struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
+ template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
+ struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
+ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+ static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
+ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+ static void TestName()
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
+ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+ static void TestName()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
+ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+ static void TestName()
+
+#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
+ template<typename Type>\
+ void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
+ {\
+ Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+ }
+
+#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
+ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+ void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
+ {\
+ Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+ }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
+ template<typename Type>\
+ void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+ {\
+ Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+ }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
+ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+ void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+ {\
+ Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+ }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
+ template<typename TestType> \
+ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
+ void test();\
+ }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
+ template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
+ void test();\
+ }
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
+ template<typename TestType> \
+ void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
+ template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+ void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_NTTP_0
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
+#else
+#define INTERNAL_CATCH_NTTP_0(signature)
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
+#endif
+
+#endif // CATCH_PREPROCESSOR_HPP_INCLUDED
+
+
+// GCC 5 and older do not properly handle disabling unused-variable warning
+// with a _Pragma. This means that we have to leak the suppression to the
+// user code as well :-(
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+#if defined(CATCH_CONFIG_DISABLE)
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... ) \
+ INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+ namespace{ \
+ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
+ INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+ } \
+ } \
+ INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+ INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
+ #else
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+ #endif
+
+ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+ INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
+ #else
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+ #endif
+
+ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+ #else
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+ #endif
+
+ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+ #else
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+ #endif
+#endif
+
+
+ ///////////////////////////////////////////////////////////////////////////////
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+ INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+ namespace {\
+ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+ INTERNAL_CATCH_TYPE_GEN\
+ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+ INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+ template<typename...Types> \
+ struct TestName{\
+ TestName(){\
+ size_t index = 0; \
+ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
+ using expander = size_t[]; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
+ (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+ }\
+ };\
+ static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+ TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+ return 0;\
+ }();\
+ }\
+ }\
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+ INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
+#else
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+ INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
+#else
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+ template<typename TestType> static void TestFuncName(); \
+ namespace {\
+ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
+ INTERNAL_CATCH_TYPE_GEN \
+ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \
+ template<typename... Types> \
+ struct TestName { \
+ void reg_tests() { \
+ size_t index = 0; \
+ using expander = size_t[]; \
+ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+ constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+ constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */\
+ } \
+ }; \
+ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+ using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
+ TestInit t; \
+ t.reg_tests(); \
+ return 0; \
+ }(); \
+ } \
+ } \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ template<typename TestType> \
+ static void TestFuncName()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T,__VA_ARGS__)
+#else
+ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__)
+#else
+ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+ #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+ template<typename TestType> static void TestFunc(); \
+ namespace {\
+ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+ INTERNAL_CATCH_TYPE_GEN\
+ template<typename... Types> \
+ struct TestName { \
+ void reg_tests() { \
+ size_t index = 0; \
+ using expander = size_t[]; \
+ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
+ } \
+ };\
+ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+ using TestInit = typename convert<TestName, TmplList>::type; \
+ TestInit t; \
+ t.reg_tests(); \
+ return 0; \
+ }(); \
+ }}\
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ template<typename TestType> \
+ static void TestFunc()
+
+ #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
+ INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, TmplList )
+
+
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ namespace {\
+ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+ INTERNAL_CATCH_TYPE_GEN\
+ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+ INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+ INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+ template<typename...Types> \
+ struct TestNameClass{\
+ TestNameClass(){\
+ size_t index = 0; \
+ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+ using expander = size_t[];\
+ (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+ }\
+ };\
+ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+ TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+ return 0;\
+ }();\
+ }\
+ }\
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ template<typename TestType> \
+ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+ void test();\
+ };\
+ namespace {\
+ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
+ INTERNAL_CATCH_TYPE_GEN \
+ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+ template<typename...Types>\
+ struct TestNameClass{\
+ void reg_tests(){\
+ std::size_t index = 0;\
+ using expander = std::size_t[];\
+ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+ constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+ constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */ \
+ }\
+ };\
+ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+ using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
+ TestInit t;\
+ t.reg_tests();\
+ return 0;\
+ }(); \
+ }\
+ }\
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ template<typename TestType> \
+ void TestName<TestType>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
+#endif
+
+ #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+ template<typename TestType> \
+ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+ void test();\
+ };\
+ namespace {\
+ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+ INTERNAL_CATCH_TYPE_GEN\
+ template<typename...Types>\
+ struct TestNameClass{\
+ void reg_tests(){\
+ size_t index = 0;\
+ using expander = size_t[];\
+ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName##_catch_sr, Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
+ }\
+ };\
+ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+ using TestInit = typename convert<TestNameClass, TmplList>::type;\
+ TestInit t;\
+ t.reg_tests();\
+ return 0;\
+ }(); \
+ }}\
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ template<typename TestType> \
+ void TestName<TestType>::test()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
+ INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, TmplList )
+
+
+#endif // CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+ #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+ #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #else
+ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+ #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+ #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+ #endif
+
+#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+ #else
+ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+ #endif
+
+ // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
+ #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+ #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+ #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+ #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+ #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #else
+ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+ #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+ #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+ #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+ #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+ #endif
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+ #else
+ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+ #endif
+
+ // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
+ #define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+ #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+ #define TEMPLATE_LIST_TEST_CASE( ... ) TEMPLATE_TEST_CASE(__VA_ARGS__)
+ #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+
+#endif // end of user facing macro declarations
+
+
+#endif // CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_CASE_INFO_HPP_INCLUDED
+#define CATCH_TEST_CASE_INFO_HPP_INCLUDED
+
+
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+ /**
+ * A **view** of a tag string that provides case insensitive comparisons
+ *
+ * Note that in Catch2 internals, the square brackets around tags are
+ * not a part of tag's representation, so e.g. "[cool-tag]" is represented
+ * as "cool-tag" internally.
+ */
+ struct Tag {
+ constexpr Tag(StringRef original_):
+ original(original_)
+ {}
+ StringRef original;
+
+ friend bool operator< ( Tag const& lhs, Tag const& rhs );
+ friend bool operator==( Tag const& lhs, Tag const& rhs );
+ };
+
+ class ITestInvoker;
+ struct NameAndTags;
+
+ enum class TestCaseProperties : uint8_t {
+ None = 0,
+ IsHidden = 1 << 1,
+ ShouldFail = 1 << 2,
+ MayFail = 1 << 3,
+ Throws = 1 << 4,
+ NonPortable = 1 << 5,
+ Benchmark = 1 << 6
+ };
+
+ /**
+ * Various metadata about the test case.
+ *
+ * A test case is uniquely identified by its (class)name and tags
+ * combination, with source location being ignored, and other properties
+ * being determined from tags.
+ *
+ * Tags are kept sorted.
+ */
+ struct TestCaseInfo : Detail::NonCopyable {
+
+ TestCaseInfo(StringRef _className,
+ NameAndTags const& _nameAndTags,
+ SourceLineInfo const& _lineInfo);
+
+ bool isHidden() const;
+ bool throws() const;
+ bool okToFail() const;
+ bool expectedToFail() const;
+
+ // Adds the tag(s) with test's filename (for the -# flag)
+ void addFilenameTag();
+
+ //! Orders by name, classname and tags
+ friend bool operator<( TestCaseInfo const& lhs,
+ TestCaseInfo const& rhs );
+
+
+ std::string tagsAsString() const;
+
+ std::string name;
+ StringRef className;
+ private:
+ std::string backingTags;
+ // Internally we copy tags to the backing storage and then add
+ // refs to this storage to the tags vector.
+ void internalAppendTag(StringRef tagString);
+ public:
+ std::vector<Tag> tags;
+ SourceLineInfo lineInfo;
+ TestCaseProperties properties = TestCaseProperties::None;
+ };
+
+ /**
+ * Wrapper over the test case information and the test case invoker
+ *
+ * Does not own either, and is specifically made to be cheap
+ * to copy around.
+ */
+ class TestCaseHandle {
+ TestCaseInfo* m_info;
+ ITestInvoker* m_invoker;
+ public:
+ TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
+ m_info(info), m_invoker(invoker) {}
+
+ void invoke() const {
+ m_invoker->invoke();
+ }
+
+ TestCaseInfo const& getTestCaseInfo() const;
+ };
+
+ Detail::unique_ptr<TestCaseInfo>
+ makeTestCaseInfo( StringRef className,
+ NameAndTags const& nameAndTags,
+ SourceLineInfo const& lineInfo );
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_TEST_CASE_INFO_HPP_INCLUDED
+
+
+#ifndef CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+#define CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+#define CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+ using exceptionTranslateFunction = std::string(*)();
+
+ class IExceptionTranslator;
+ using ExceptionTranslators = std::vector<Detail::unique_ptr<IExceptionTranslator const>>;
+
+ class IExceptionTranslator {
+ public:
+ virtual ~IExceptionTranslator(); // = default
+ virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
+ };
+
+ class IExceptionTranslatorRegistry {
+ public:
+ virtual ~IExceptionTranslatorRegistry(); // = default
+ virtual std::string translateActiveException() const = 0;
+ };
+
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+
+#include <exception>
+
+namespace Catch {
+ namespace Detail {
+ void registerTranslatorImpl(
+ Detail::unique_ptr<IExceptionTranslator>&& translator );
+ }
+
+ class ExceptionTranslatorRegistrar {
+ template<typename T>
+ class ExceptionTranslator : public IExceptionTranslator {
+ public:
+
+ ExceptionTranslator( std::string(*translateFunction)( T const& ) )
+ : m_translateFunction( translateFunction )
+ {}
+
+ std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+ try {
+ if( it == itEnd )
+ std::rethrow_exception(std::current_exception());
+ else
+ return (*it)->translate( it+1, itEnd );
+ }
+ catch( T const& ex ) {
+ return m_translateFunction( ex );
+ }
+#else
+ return "You should never get here!";
+#endif
+ }
+
+ protected:
+ std::string(*m_translateFunction)( T const& );
+ };
+
+ public:
+ template<typename T>
+ ExceptionTranslatorRegistrar( std::string(*translateFunction)( T const& ) ) {
+ Detail::registerTranslatorImpl(
+ Detail::make_unique<ExceptionTranslator<T>>(
+ translateFunction ) );
+ }
+ };
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
+ static std::string translatorName( signature ); \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+ static std::string translatorName( signature )
+
+#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+#if defined(CATCH_CONFIG_DISABLE)
+ #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
+ static std::string translatorName( signature )
+#endif
+
+
+// This macro is always prefixed
+#if !defined(CATCH_CONFIG_DISABLE)
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+#else
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+#endif
+
+
+#endif // CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_VERSION_HPP_INCLUDED
+#define CATCH_VERSION_HPP_INCLUDED
+
+#include <iosfwd>
+
+namespace Catch {
+
+ // Versioning information
+ struct Version {
+ Version( Version const& ) = delete;
+ Version& operator=( Version const& ) = delete;
+ Version( unsigned int _majorVersion,
+ unsigned int _minorVersion,
+ unsigned int _patchNumber,
+ char const * const _branchName,
+ unsigned int _buildNumber );
+
+ unsigned int const majorVersion;
+ unsigned int const minorVersion;
+ unsigned int const patchNumber;
+
+ // buildNumber is only used if branchName is not null
+ char const * const branchName;
+ unsigned int const buildNumber;
+
+ friend std::ostream& operator << ( std::ostream& os, Version const& version );
+ };
+
+ Version const& libraryVersion();
+}
+
+#endif // CATCH_VERSION_HPP_INCLUDED
+
+
+#ifndef CATCH_VERSION_MACROS_HPP_INCLUDED
+#define CATCH_VERSION_MACROS_HPP_INCLUDED
+
+#define CATCH_VERSION_MAJOR 3
+#define CATCH_VERSION_MINOR 6
+#define CATCH_VERSION_PATCH 0
+
+#endif // CATCH_VERSION_MACROS_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's Generator support. It includes
+ * **all** of Catch2 headers related to generators.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header is added to either the `generators` folder,
+ * or to the corresponding internal subfolder, it should be added here.
+ */
+
+#ifndef CATCH_GENERATORS_ALL_HPP_INCLUDED
+#define CATCH_GENERATORS_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+#define CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+
+#include <exception>
+
+namespace Catch {
+
+ // Exception type to be thrown when a Generator runs into an error,
+ // e.g. it cannot initialize the first return value based on
+ // runtime information
+ class GeneratorException : public std::exception {
+ const char* const m_msg = "";
+
+ public:
+ GeneratorException(const char* msg):
+ m_msg(msg)
+ {}
+
+ const char* what() const noexcept override final;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_HPP_INCLUDED
+#define CATCH_GENERATORS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+#define CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+ namespace Generators {
+ class GeneratorUntypedBase {
+ // Caches result from `toStringImpl`, assume that when it is an
+ // empty string, the cache is invalidated.
+ mutable std::string m_stringReprCache;
+
+ // Counts based on `next` returning true
+ std::size_t m_currentElementIndex = 0;
+
+ /**
+ * Attempts to move the generator to the next element
+ *
+ * Returns true iff the move succeeded (and a valid element
+ * can be retrieved).
+ */
+ virtual bool next() = 0;
+
+ //! Customization point for `currentElementAsString`
+ virtual std::string stringifyImpl() const = 0;
+
+ public:
+ GeneratorUntypedBase() = default;
+ // Generation of copy ops is deprecated (and Clang will complain)
+ // if there is a user destructor defined
+ GeneratorUntypedBase(GeneratorUntypedBase const&) = default;
+ GeneratorUntypedBase& operator=(GeneratorUntypedBase const&) = default;
+
+ virtual ~GeneratorUntypedBase(); // = default;
+
+ /**
+ * Attempts to move the generator to the next element
+ *
+ * Serves as a non-virtual interface to `next`, so that the
+ * top level interface can provide sanity checking and shared
+ * features.
+ *
+ * As with `next`, returns true iff the move succeeded and
+ * the generator has new valid element to provide.
+ */
+ bool countedNext();
+
+ std::size_t currentElementIndex() const { return m_currentElementIndex; }
+
+ /**
+ * Returns generator's current element as user-friendly string.
+ *
+ * By default returns string equivalent to calling
+ * `Catch::Detail::stringify` on the current element, but generators
+ * can customize their implementation as needed.
+ *
+ * Not thread-safe due to internal caching.
+ *
+ * The returned ref is valid only until the generator instance
+ * is destructed, or it moves onto the next element, whichever
+ * comes first.
+ */
+ StringRef currentElementAsString() const;
+ };
+ using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
+
+ } // namespace Generators
+
+ class IGeneratorTracker {
+ public:
+ virtual ~IGeneratorTracker(); // = default;
+ virtual auto hasGenerator() const -> bool = 0;
+ virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
+ virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
+ };
+
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+
+#include <vector>
+#include <tuple>
+
+namespace Catch {
+
+namespace Generators {
+
+namespace Detail {
+
+ //! Throws GeneratorException with the provided message
+ [[noreturn]]
+ void throw_generator_exception(char const * msg);
+
+} // end namespace detail
+
+ template<typename T>
+ class IGenerator : public GeneratorUntypedBase {
+ std::string stringifyImpl() const override {
+ return ::Catch::Detail::stringify( get() );
+ }
+
+ public:
+ // Returns the current element of the generator
+ //
+ // \Precondition The generator is either freshly constructed,
+ // or the last call to `next()` returned true
+ virtual T const& get() const = 0;
+ using type = T;
+ };
+
+ template <typename T>
+ using GeneratorPtr = Catch::Detail::unique_ptr<IGenerator<T>>;
+
+ template <typename T>
+ class GeneratorWrapper final {
+ GeneratorPtr<T> m_generator;
+ public:
+ //! Takes ownership of the passed pointer.
+ GeneratorWrapper(IGenerator<T>* generator):
+ m_generator(generator) {}
+ GeneratorWrapper(GeneratorPtr<T> generator):
+ m_generator(CATCH_MOVE(generator)) {}
+
+ T const& get() const {
+ return m_generator->get();
+ }
+ bool next() {
+ return m_generator->countedNext();
+ }
+ };
+
+
+ template<typename T>
+ class SingleValueGenerator final : public IGenerator<T> {
+ T m_value;
+ public:
+ SingleValueGenerator(T const& value) :
+ m_value(value)
+ {}
+ SingleValueGenerator(T&& value):
+ m_value(CATCH_MOVE(value))
+ {}
+
+ T const& get() const override {
+ return m_value;
+ }
+ bool next() override {
+ return false;
+ }
+ };
+
+ template<typename T>
+ class FixedValuesGenerator final : public IGenerator<T> {
+ static_assert(!std::is_same<T, bool>::value,
+ "FixedValuesGenerator does not support bools because of std::vector<bool>"
+ "specialization, use SingleValue Generator instead.");
+ std::vector<T> m_values;
+ size_t m_idx = 0;
+ public:
+ FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
+
+ T const& get() const override {
+ return m_values[m_idx];
+ }
+ bool next() override {
+ ++m_idx;
+ return m_idx < m_values.size();
+ }
+ };
+
+ template <typename T, typename DecayedT = std::decay_t<T>>
+ GeneratorWrapper<DecayedT> value( T&& value ) {
+ return GeneratorWrapper<DecayedT>(
+ Catch::Detail::make_unique<SingleValueGenerator<DecayedT>>(
+ CATCH_FORWARD( value ) ) );
+ }
+ template <typename T>
+ GeneratorWrapper<T> values(std::initializer_list<T> values) {
+ return GeneratorWrapper<T>(Catch::Detail::make_unique<FixedValuesGenerator<T>>(values));
+ }
+
+ template<typename T>
+ class Generators : public IGenerator<T> {
+ std::vector<GeneratorWrapper<T>> m_generators;
+ size_t m_current = 0;
+
+ void add_generator( GeneratorWrapper<T>&& generator ) {
+ m_generators.emplace_back( CATCH_MOVE( generator ) );
+ }
+ void add_generator( T const& val ) {
+ m_generators.emplace_back( value( val ) );
+ }
+ void add_generator( T&& val ) {
+ m_generators.emplace_back( value( CATCH_MOVE( val ) ) );
+ }
+ template <typename U>
+ std::enable_if_t<!std::is_same<std::decay_t<U>, T>::value>
+ add_generator( U&& val ) {
+ add_generator( T( CATCH_FORWARD( val ) ) );
+ }
+
+ template <typename U> void add_generators( U&& valueOrGenerator ) {
+ add_generator( CATCH_FORWARD( valueOrGenerator ) );
+ }
+
+ template <typename U, typename... Gs>
+ void add_generators( U&& valueOrGenerator, Gs&&... moreGenerators ) {
+ add_generator( CATCH_FORWARD( valueOrGenerator ) );
+ add_generators( CATCH_FORWARD( moreGenerators )... );
+ }
+
+ public:
+ template <typename... Gs>
+ Generators(Gs &&... moreGenerators) {
+ m_generators.reserve(sizeof...(Gs));
+ add_generators(CATCH_FORWARD(moreGenerators)...);
+ }
+
+ T const& get() const override {
+ return m_generators[m_current].get();
+ }
+
+ bool next() override {
+ if (m_current >= m_generators.size()) {
+ return false;
+ }
+ const bool current_status = m_generators[m_current].next();
+ if (!current_status) {
+ ++m_current;
+ }
+ return m_current < m_generators.size();
+ }
+ };
+
+
+ template <typename... Ts>
+ GeneratorWrapper<std::tuple<std::decay_t<Ts>...>>
+ table( std::initializer_list<std::tuple<std::decay_t<Ts>...>> tuples ) {
+ return values<std::tuple<Ts...>>( tuples );
+ }
+
+ // Tag type to signal that a generator sequence should convert arguments to a specific type
+ template <typename T>
+ struct as {};
+
+ template<typename T, typename... Gs>
+ auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
+ return Generators<T>(CATCH_MOVE(generator), CATCH_FORWARD(moreGenerators)...);
+ }
+ template<typename T>
+ auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
+ return Generators<T>(CATCH_MOVE(generator));
+ }
+ template<typename T, typename... Gs>
+ auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<std::decay_t<T>> {
+ return makeGenerators( value( CATCH_FORWARD( val ) ), CATCH_FORWARD( moreGenerators )... );
+ }
+ template<typename T, typename U, typename... Gs>
+ auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
+ return makeGenerators( value( T( CATCH_FORWARD( val ) ) ), CATCH_FORWARD( moreGenerators )... );
+ }
+
+ IGeneratorTracker* acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo );
+ IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+ SourceLineInfo lineInfo,
+ GeneratorBasePtr&& generator );
+
+ template<typename L>
+ auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> typename decltype(generatorExpression())::type {
+ using UnderlyingType = typename decltype(generatorExpression())::type;
+
+ IGeneratorTracker* tracker = acquireGeneratorTracker( generatorName, lineInfo );
+ // Creation of tracker is delayed after generator creation, so
+ // that constructing generator can fail without breaking everything.
+ if (!tracker) {
+ tracker = createGeneratorTracker(
+ generatorName,
+ lineInfo,
+ Catch::Detail::make_unique<Generators<UnderlyingType>>(
+ generatorExpression() ) );
+ }
+
+ auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker->getGenerator() );
+ return generator.get();
+ }
+
+} // namespace Generators
+} // namespace Catch
+
+#define CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL( ... ) #__VA_ARGS__##_catch_sr
+#define CATCH_INTERNAL_GENERATOR_STRINGIZE(...) CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL(__VA_ARGS__)
+
+#define GENERATE( ... ) \
+ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+ CATCH_INTERNAL_LINEINFO, \
+ [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_COPY( ... ) \
+ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+ CATCH_INTERNAL_LINEINFO, \
+ [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_REF( ... ) \
+ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+ CATCH_INTERNAL_LINEINFO, \
+ [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+
+#endif // CATCH_GENERATORS_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+#define CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+
+
+#include <cassert>
+
+namespace Catch {
+namespace Generators {
+
+ template <typename T>
+ class TakeGenerator final : public IGenerator<T> {
+ GeneratorWrapper<T> m_generator;
+ size_t m_returned = 0;
+ size_t m_target;
+ public:
+ TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
+ m_generator(CATCH_MOVE(generator)),
+ m_target(target)
+ {
+ assert(target != 0 && "Empty generators are not allowed");
+ }
+ T const& get() const override {
+ return m_generator.get();
+ }
+ bool next() override {
+ ++m_returned;
+ if (m_returned >= m_target) {
+ return false;
+ }
+
+ const auto success = m_generator.next();
+ // If the underlying generator does not contain enough values
+ // then we cut short as well
+ if (!success) {
+ m_returned = m_target;
+ }
+ return success;
+ }
+ };
+
+ template <typename T>
+ GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
+ return GeneratorWrapper<T>(Catch::Detail::make_unique<TakeGenerator<T>>(target, CATCH_MOVE(generator)));
+ }
+
+
+ template <typename T, typename Predicate>
+ class FilterGenerator final : public IGenerator<T> {
+ GeneratorWrapper<T> m_generator;
+ Predicate m_predicate;
+ public:
+ template <typename P = Predicate>
+ FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
+ m_generator(CATCH_MOVE(generator)),
+ m_predicate(CATCH_FORWARD(pred))
+ {
+ if (!m_predicate(m_generator.get())) {
+ // It might happen that there are no values that pass the
+ // filter. In that case we throw an exception.
+ auto has_initial_value = next();
+ if (!has_initial_value) {
+ Detail::throw_generator_exception("No valid value found in filtered generator");
+ }
+ }
+ }
+
+ T const& get() const override {
+ return m_generator.get();
+ }
+
+ bool next() override {
+ bool success = m_generator.next();
+ if (!success) {
+ return false;
+ }
+ while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
+ return success;
+ }
+ };
+
+
+ template <typename T, typename Predicate>
+ GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
+ return GeneratorWrapper<T>(Catch::Detail::make_unique<FilterGenerator<T, Predicate>>(CATCH_FORWARD(pred), CATCH_MOVE(generator)));
+ }
+
+ template <typename T>
+ class RepeatGenerator final : public IGenerator<T> {
+ static_assert(!std::is_same<T, bool>::value,
+ "RepeatGenerator currently does not support bools"
+ "because of std::vector<bool> specialization");
+ GeneratorWrapper<T> m_generator;
+ mutable std::vector<T> m_returned;
+ size_t m_target_repeats;
+ size_t m_current_repeat = 0;
+ size_t m_repeat_index = 0;
+ public:
+ RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
+ m_generator(CATCH_MOVE(generator)),
+ m_target_repeats(repeats)
+ {
+ assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+ }
+
+ T const& get() const override {
+ if (m_current_repeat == 0) {
+ m_returned.push_back(m_generator.get());
+ return m_returned.back();
+ }
+ return m_returned[m_repeat_index];
+ }
+
+ bool next() override {
+ // There are 2 basic cases:
+ // 1) We are still reading the generator
+ // 2) We are reading our own cache
+
+ // In the first case, we need to poke the underlying generator.
+ // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
+ if (m_current_repeat == 0) {
+ const auto success = m_generator.next();
+ if (!success) {
+ ++m_current_repeat;
+ }
+ return m_current_repeat < m_target_repeats;
+ }
+
+ // In the second case, we need to move indices forward and check that we haven't run up against the end
+ ++m_repeat_index;
+ if (m_repeat_index == m_returned.size()) {
+ m_repeat_index = 0;
+ ++m_current_repeat;
+ }
+ return m_current_repeat < m_target_repeats;
+ }
+ };
+
+ template <typename T>
+ GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
+ return GeneratorWrapper<T>(Catch::Detail::make_unique<RepeatGenerator<T>>(repeats, CATCH_MOVE(generator)));
+ }
+
+ template <typename T, typename U, typename Func>
+ class MapGenerator final : public IGenerator<T> {
+ // TBD: provide static assert for mapping function, for friendly error message
+ GeneratorWrapper<U> m_generator;
+ Func m_function;
+ // To avoid returning dangling reference, we have to save the values
+ T m_cache;
+ public:
+ template <typename F2 = Func>
+ MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
+ m_generator(CATCH_MOVE(generator)),
+ m_function(CATCH_FORWARD(function)),
+ m_cache(m_function(m_generator.get()))
+ {}
+
+ T const& get() const override {
+ return m_cache;
+ }
+ bool next() override {
+ const auto success = m_generator.next();
+ if (success) {
+ m_cache = m_function(m_generator.get());
+ }
+ return success;
+ }
+ };
+
+ template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
+ GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+ return GeneratorWrapper<T>(
+ Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
+ );
+ }
+
+ template <typename T, typename U, typename Func>
+ GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+ return GeneratorWrapper<T>(
+ Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
+ );
+ }
+
+ template <typename T>
+ class ChunkGenerator final : public IGenerator<std::vector<T>> {
+ std::vector<T> m_chunk;
+ size_t m_chunk_size;
+ GeneratorWrapper<T> m_generator;
+ bool m_used_up = false;
+ public:
+ ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
+ m_chunk_size(size), m_generator(CATCH_MOVE(generator))
+ {
+ m_chunk.reserve(m_chunk_size);
+ if (m_chunk_size != 0) {
+ m_chunk.push_back(m_generator.get());
+ for (size_t i = 1; i < m_chunk_size; ++i) {
+ if (!m_generator.next()) {
+ Detail::throw_generator_exception("Not enough values to initialize the first chunk");
+ }
+ m_chunk.push_back(m_generator.get());
+ }
+ }
+ }
+ std::vector<T> const& get() const override {
+ return m_chunk;
+ }
+ bool next() override {
+ m_chunk.clear();
+ for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+ if (!m_generator.next()) {
+ return false;
+ }
+ m_chunk.push_back(m_generator.get());
+ }
+ return true;
+ }
+ };
+
+ template <typename T>
+ GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
+ return GeneratorWrapper<std::vector<T>>(
+ Catch::Detail::make_unique<ChunkGenerator<T>>(size, CATCH_MOVE(generator))
+ );
+ }
+
+} // namespace Generators
+} // namespace Catch
+
+
+#endif // CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+#define CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+
+
+
+#ifndef CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+#define CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+ // This is a simple implementation of C++11 Uniform Random Number
+ // Generator. It does not provide all operators, because Catch2
+ // does not use it, but it should behave as expected inside stdlib's
+ // distributions.
+ // The implementation is based on the PCG family (http://pcg-random.org)
+ class SimplePcg32 {
+ using state_type = std::uint64_t;
+ public:
+ using result_type = std::uint32_t;
+ static constexpr result_type (min)() {
+ return 0;
+ }
+ static constexpr result_type (max)() {
+ return static_cast<result_type>(-1);
+ }
+
+ // Provide some default initial state for the default constructor
+ SimplePcg32():SimplePcg32(0xed743cc4U) {}
+
+ explicit SimplePcg32(result_type seed_);
+
+ void seed(result_type seed_);
+ void discard(uint64_t skip);
+
+ result_type operator()();
+
+ private:
+ friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+ friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+
+ // In theory we also need operator<< and operator>>
+ // In practice we do not use them, so we will skip them for now
+
+
+ std::uint64_t m_state;
+ // This part of the state determines which "stream" of the numbers
+ // is chosen -- we take it as a constant for Catch2, so we only
+ // need to deal with seeding the main state.
+ // Picked by reading 8 bytes from `/dev/random` :-)
+ static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+
+
+
+#ifndef CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
+#define CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
+
+
+
+
+#ifndef CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
+#define CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
+
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+// Note: We use the usual enable-disable-autodetect dance here even though
+// we do not support these in CMake configuration options (yet?).
+// It is highly unlikely that we will need to make these actually
+// user-configurable, but this will make it simpler if weend up needing
+// it, and it provides an escape hatch to the users who need it.
+#if defined( __SIZEOF_INT128__ )
+# define CATCH_CONFIG_INTERNAL_UINT128
+// Unlike GCC, MSVC does not polyfill umul as mulh + mul pair on ARM machines.
+// Currently we do not bother doing this ourselves, but we could if it became
+// important for perf.
+#elif defined( _MSC_VER ) && defined( _M_X64 )
+# define CATCH_CONFIG_INTERNAL_MSVC_UMUL128
+#endif
+
+#if defined( CATCH_CONFIG_INTERNAL_UINT128 ) && \
+ !defined( CATCH_CONFIG_NO_UINT128 ) && \
+ !defined( CATCH_CONFIG_UINT128 )
+#define CATCH_CONFIG_UINT128
+#endif
+
+#if defined( CATCH_CONFIG_INTERNAL_MSVC_UMUL128 ) && \
+ !defined( CATCH_CONFIG_NO_MSVC_UMUL128 ) && \
+ !defined( CATCH_CONFIG_MSVC_UMUL128 )
+# define CATCH_CONFIG_MSVC_UMUL128
+# include <intrin.h>
+#endif
+
+
+namespace Catch {
+ namespace Detail {
+
+ template <std::size_t>
+ struct SizedUnsignedType;
+#define SizedUnsignedTypeHelper( TYPE ) \
+ template <> \
+ struct SizedUnsignedType<sizeof( TYPE )> { \
+ using type = TYPE; \
+ }
+
+ SizedUnsignedTypeHelper( std::uint8_t );
+ SizedUnsignedTypeHelper( std::uint16_t );
+ SizedUnsignedTypeHelper( std::uint32_t );
+ SizedUnsignedTypeHelper( std::uint64_t );
+#undef SizedUnsignedTypeHelper
+
+ template <std::size_t sz>
+ using SizedUnsignedType_t = typename SizedUnsignedType<sz>::type;
+
+ template <typename T>
+ using DoubleWidthUnsignedType_t = SizedUnsignedType_t<2 * sizeof( T )>;
+
+ template <typename T>
+ struct ExtendedMultResult {
+ T upper;
+ T lower;
+ bool operator==( ExtendedMultResult const& rhs ) const {
+ return upper == rhs.upper && lower == rhs.lower;
+ }
+ };
+
+ /**
+ * Returns 128 bit result of lhs * rhs using portable C++ code
+ *
+ * This implementation is almost twice as fast as naive long multiplication,
+ * and unlike intrinsic-based approach, it supports constexpr evaluation.
+ */
+ constexpr ExtendedMultResult<std::uint64_t>
+ extendedMultPortable(std::uint64_t lhs, std::uint64_t rhs) {
+#define CarryBits( x ) ( x >> 32 )
+#define Digits( x ) ( x & 0xFF'FF'FF'FF )
+ std::uint64_t lhs_low = Digits( lhs );
+ std::uint64_t rhs_low = Digits( rhs );
+ std::uint64_t low_low = ( lhs_low * rhs_low );
+ std::uint64_t high_high = CarryBits( lhs ) * CarryBits( rhs );
+
+ // We add in carry bits from low-low already
+ std::uint64_t high_low =
+ ( CarryBits( lhs ) * rhs_low ) + CarryBits( low_low );
+ // Note that we can add only low bits from high_low, to avoid
+ // overflow with large inputs
+ std::uint64_t low_high =
+ ( lhs_low * CarryBits( rhs ) ) + Digits( high_low );
+
+ return { high_high + CarryBits( high_low ) + CarryBits( low_high ),
+ ( low_high << 32 ) | Digits( low_low ) };
+#undef CarryBits
+#undef Digits
+ }
+
+ //! Returns 128 bit result of lhs * rhs
+ inline ExtendedMultResult<std::uint64_t>
+ extendedMult( std::uint64_t lhs, std::uint64_t rhs ) {
+#if defined( CATCH_CONFIG_UINT128 )
+ auto result = __uint128_t( lhs ) * __uint128_t( rhs );
+ return { static_cast<std::uint64_t>( result >> 64 ),
+ static_cast<std::uint64_t>( result ) };
+#elif defined( CATCH_CONFIG_MSVC_UMUL128 )
+ std::uint64_t high;
+ std::uint64_t low = _umul128( lhs, rhs, &high );
+ return { high, low };
+#else
+ return extendedMultPortable( lhs, rhs );
+#endif
+ }
+
+
+ template <typename UInt>
+ constexpr ExtendedMultResult<UInt> extendedMult( UInt lhs, UInt rhs ) {
+ static_assert( std::is_unsigned<UInt>::value,
+ "extendedMult can only handle unsigned integers" );
+ static_assert( sizeof( UInt ) < sizeof( std::uint64_t ),
+ "Generic extendedMult can only handle types smaller "
+ "than uint64_t" );
+ using WideType = DoubleWidthUnsignedType_t<UInt>;
+
+ auto result = WideType( lhs ) * WideType( rhs );
+ return {
+ static_cast<UInt>( result >> ( CHAR_BIT * sizeof( UInt ) ) ),
+ static_cast<UInt>( result & UInt( -1 ) ) };
+ }
+
+
+ template <typename TargetType,
+ typename Generator>
+ std::enable_if_t<sizeof(typename Generator::result_type) >= sizeof(TargetType),
+ TargetType> fillBitsFrom(Generator& gen) {
+ using gresult_type = typename Generator::result_type;
+ static_assert( std::is_unsigned<TargetType>::value, "Only unsigned integers are supported" );
+ static_assert( Generator::min() == 0 &&
+ Generator::max() == static_cast<gresult_type>( -1 ),
+ "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );
+
+ // We want to return the top bits from a generator, as they are
+ // usually considered higher quality.
+ constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
+ constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;
+
+ return static_cast<TargetType>( gen() >>
+ ( generated_bits - return_bits) );
+ }
+
+ template <typename TargetType,
+ typename Generator>
+ std::enable_if_t<sizeof(typename Generator::result_type) < sizeof(TargetType),
+ TargetType> fillBitsFrom(Generator& gen) {
+ using gresult_type = typename Generator::result_type;
+ static_assert( std::is_unsigned<TargetType>::value,
+ "Only unsigned integers are supported" );
+ static_assert( Generator::min() == 0 &&
+ Generator::max() == static_cast<gresult_type>( -1 ),
+ "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );
+
+ constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
+ constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;
+ std::size_t filled_bits = 0;
+ TargetType ret = 0;
+ do {
+ ret <<= generated_bits;
+ ret |= gen();
+ filled_bits += generated_bits;
+ } while ( filled_bits < return_bits );
+
+ return ret;
+ }
+
+ /*
+ * Transposes numbers into unsigned type while keeping their ordering
+ *
+ * This means that signed types are changed so that the ordering is
+ * [INT_MIN, ..., -1, 0, ..., INT_MAX], rather than order we would
+ * get by simple casting ([0, ..., INT_MAX, INT_MIN, ..., -1])
+ */
+ template <typename OriginalType, typename UnsignedType>
+ std::enable_if_t<std::is_signed<OriginalType>::value, UnsignedType>
+ transposeToNaturalOrder( UnsignedType in ) {
+ static_assert(
+ sizeof( OriginalType ) == sizeof( UnsignedType ),
+ "reordering requires the same sized types on both sides" );
+ static_assert( std::is_unsigned<UnsignedType>::value,
+ "Input type must be unsigned" );
+ // Assuming 2s complement (standardized in current C++), the
+ // positive and negative numbers are already internally ordered,
+ // and their difference is in the top bit. Swapping it orders
+ // them the desired way.
+ constexpr auto highest_bit =
+ UnsignedType( 1 ) << ( sizeof( UnsignedType ) * CHAR_BIT - 1 );
+ return static_cast<UnsignedType>( in ^ highest_bit );
+ }
+
+
+
+ template <typename OriginalType,
+ typename UnsignedType>
+ std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
+ transposeToNaturalOrder(UnsignedType in) {
+ static_assert(
+ sizeof( OriginalType ) == sizeof( UnsignedType ),
+ "reordering requires the same sized types on both sides" );
+ static_assert( std::is_unsigned<UnsignedType>::value, "Input type must be unsigned" );
+ // No reordering is needed for unsigned -> unsigned
+ return in;
+ }
+ } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
+
+namespace Catch {
+
+/**
+ * Implementation of uniform distribution on integers.
+ *
+ * Unlike `std::uniform_int_distribution`, this implementation supports
+ * various 1 byte integral types, including bool (but you should not
+ * actually use it for bools).
+ *
+ * The underlying algorithm is based on the one described in "Fast Random
+ * Integer Generation in an Interval" by Daniel Lemire, but has been
+ * optimized under the assumption of reuse of the same distribution object.
+ */
+template <typename IntegerType>
+class uniform_integer_distribution {
+ static_assert(std::is_integral<IntegerType>::value, "...");
+
+ using UnsignedIntegerType = Detail::SizedUnsignedType_t<sizeof(IntegerType)>;
+
+ // Only the left bound is stored, and we store it converted to its
+ // unsigned image. This avoids having to do the conversions inside
+ // the operator(), at the cost of having to do the conversion in
+ // the a() getter. The right bound is only needed in the b() getter,
+ // so we recompute it there from other stored data.
+ UnsignedIntegerType m_a;
+
+ // How many different values are there in [a, b]. a == b => 1, can be 0 for distribution over all values in the type.
+ UnsignedIntegerType m_ab_distance;
+
+ // We hoisted this out of the main generation function. Technically,
+ // this means that using this distribution will be slower than Lemire's
+ // algorithm if this distribution instance will be used only few times,
+ // but it will be faster if it is used many times. Since Catch2 uses
+ // distributions only to implement random generators, we assume that each
+ // distribution will be reused many times and this is an optimization.
+ UnsignedIntegerType m_rejection_threshold = 0;
+
+ UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) const {
+ // This overflows and returns 0 if a == 0 and b == TYPE_MAX.
+ // We handle that later when generating the number.
+ return transposeTo(b) - transposeTo(a) + 1;
+ }
+
+ static UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
+ // distance == 0 means that we will return all possible values from
+ // the type's range, and that we shouldn't reject anything.
+ if ( ab_distance == 0 ) { return 0; }
+ return ( ~ab_distance + 1 ) % ab_distance;
+ }
+
+ static UnsignedIntegerType transposeTo(IntegerType in) {
+ return Detail::transposeToNaturalOrder<IntegerType>(
+ static_cast<UnsignedIntegerType>( in ) );
+ }
+ static IntegerType transposeBack(UnsignedIntegerType in) {
+ return static_cast<IntegerType>(
+ Detail::transposeToNaturalOrder<IntegerType>(in) );
+ }
+
+public:
+ using result_type = IntegerType;
+
+ uniform_integer_distribution( IntegerType a, IntegerType b ):
+ m_a( transposeTo(a) ),
+ m_ab_distance( computeDistance(a, b) ),
+ m_rejection_threshold( computeRejectionThreshold(m_ab_distance) ) {
+ assert( a <= b );
+ }
+
+ template <typename Generator>
+ result_type operator()( Generator& g ) {
+ // All possible values of result_type are valid.
+ if ( m_ab_distance == 0 ) {
+ return transposeBack( Detail::fillBitsFrom<UnsignedIntegerType>( g ) );
+ }
+
+ auto random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
+ auto emul = Detail::extendedMult( random_number, m_ab_distance );
+ // Unlike Lemire's algorithm we skip the ab_distance check, since
+ // we precomputed the rejection threshold, which is always tighter.
+ while (emul.lower < m_rejection_threshold) {
+ random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
+ emul = Detail::extendedMult( random_number, m_ab_distance );
+ }
+
+ return transposeBack(m_a + emul.upper);
+ }
+
+ result_type a() const { return transposeBack(m_a); }
+ result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
+};
+
+} // end namespace Catch
+
+#endif // CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
+
+
+
+#ifndef CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
+#define CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
+
+
+
+
+#ifndef CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
+#define CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_POLYFILLS_HPP_INCLUDED
+#define CATCH_POLYFILLS_HPP_INCLUDED
+
+namespace Catch {
+
+ bool isnan(float f);
+ bool isnan(double d);
+
+ float nextafter(float x, float y);
+ double nextafter(double x, double y);
+
+}
+
+#endif // CATCH_POLYFILLS_HPP_INCLUDED
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+namespace Catch {
+
+ namespace Detail {
+ /**
+ * Returns the largest magnitude of 1-ULP distance inside the [a, b] range.
+ *
+ * Assumes `a < b`.
+ */
+ template <typename FloatType>
+ FloatType gamma(FloatType a, FloatType b) {
+ static_assert( std::is_floating_point<FloatType>::value,
+ "gamma returns the largest ULP magnitude within "
+ "floating point range [a, b]. This only makes sense "
+ "for floating point types" );
+ assert( a <= b );
+
+ const auto gamma_up = Catch::nextafter( a, std::numeric_limits<FloatType>::infinity() ) - a;
+ const auto gamma_down = b - Catch::nextafter( b, -std::numeric_limits<FloatType>::infinity() );
+
+ return gamma_up < gamma_down ? gamma_down : gamma_up;
+ }
+
+ template <typename FloatingPoint>
+ struct DistanceTypePicker;
+ template <>
+ struct DistanceTypePicker<float> {
+ using type = std::uint32_t;
+ };
+ template <>
+ struct DistanceTypePicker<double> {
+ using type = std::uint64_t;
+ };
+
+ template <typename T>
+ using DistanceType = typename DistanceTypePicker<T>::type;
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+ /**
+ * Computes the number of equi-distant floats in [a, b]
+ *
+ * Since not every range can be split into equidistant floats
+ * exactly, we actually compute ceil(b/distance - a/distance),
+ * because in those cases we want to overcount.
+ *
+ * Uses modified Dekker's FastTwoSum algorithm to handle rounding.
+ */
+ template <typename FloatType>
+ DistanceType<FloatType>
+ count_equidistant_floats( FloatType a, FloatType b, FloatType distance ) {
+ assert( a <= b );
+ // We get distance as gamma for our uniform float distribution,
+ // so this will round perfectly.
+ const auto ag = a / distance;
+ const auto bg = b / distance;
+
+ const auto s = bg - ag;
+ const auto err = ( std::fabs( a ) <= std::fabs( b ) )
+ ? -ag - ( s - bg )
+ : bg - ( s + ag );
+ const auto ceil_s = static_cast<DistanceType<FloatType>>( std::ceil( s ) );
+
+ return ( ceil_s != s ) ? ceil_s : ceil_s + ( err > 0 );
+ }
+#if defined( __GNUC__ ) || defined( __clang__ )
+# pragma GCC diagnostic pop
+#endif
+
+ }
+
+} // end namespace Catch
+
+#endif // CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
+
+#include <cmath>
+#include <type_traits>
+
+namespace Catch {
+
+ namespace Detail {
+#if defined( __GNUC__ ) || defined( __clang__ )
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+ // The issue with overflow only happens with maximal ULP and HUGE
+ // distance, e.g. when generating numbers in [-inf, inf] for given
+ // type. So we only check for the largest possible ULP in the
+ // type, and return something that does not overflow to inf in 1 mult.
+ constexpr std::uint64_t calculate_max_steps_in_one_go(double gamma) {
+ if ( gamma == 1.99584030953472e+292 ) { return 9007199254740991; }
+ return static_cast<std::uint64_t>( -1 );
+ }
+ constexpr std::uint32_t calculate_max_steps_in_one_go(float gamma) {
+ if ( gamma == 2.028241e+31f ) { return 16777215; }
+ return static_cast<std::uint32_t>( -1 );
+ }
+#if defined( __GNUC__ ) || defined( __clang__ )
+# pragma GCC diagnostic pop
+#endif
+ }
+
+/**
+ * Implementation of uniform distribution on floating point numbers.
+ *
+ * Note that we support only `float` and `double` types, because these
+ * usually mean the same thing across different platform. `long double`
+ * varies wildly by platform and thus we cannot provide reproducible
+ * implementation. Also note that we don't implement all parts of
+ * distribution per standard: this distribution is not serializable, nor
+ * can the range be arbitrarily reset.
+ *
+ * The implementation also uses different approach than the one taken by
+ * `std::uniform_real_distribution`, where instead of generating a number
+ * between [0, 1) and then multiplying the range bounds with it, we first
+ * split the [a, b] range into a set of equidistributed floating point
+ * numbers, and then use uniform int distribution to pick which one to
+ * return.
+ *
+ * This has the advantage of guaranteeing uniformity (the multiplication
+ * method loses uniformity due to rounding when multiplying floats), except
+ * for small non-uniformity at one side of the interval, where we have
+ * to deal with the fact that not every interval is splittable into
+ * equidistributed floats.
+ *
+ * Based on "Drawing random floating-point numbers from an interval" by
+ * Frederic Goualard.
+ */
+template <typename FloatType>
+class uniform_floating_point_distribution {
+ static_assert(std::is_floating_point<FloatType>::value, "...");
+ static_assert(!std::is_same<FloatType, long double>::value,
+ "We do not support long double due to inconsistent behaviour between platforms");
+
+ using WidthType = Detail::DistanceType<FloatType>;
+
+ FloatType m_a, m_b;
+ FloatType m_ulp_magnitude;
+ WidthType m_floats_in_range;
+ uniform_integer_distribution<WidthType> m_int_dist;
+
+ // In specific cases, we can overflow into `inf` when computing the
+ // `steps * g` offset. To avoid this, we don't offset by more than this
+ // in one multiply + addition.
+ WidthType m_max_steps_in_one_go;
+ // We don't want to do the magnitude check every call to `operator()`
+ bool m_a_has_leq_magnitude;
+
+public:
+ using result_type = FloatType;
+
+ uniform_floating_point_distribution( FloatType a, FloatType b ):
+ m_a( a ),
+ m_b( b ),
+ m_ulp_magnitude( Detail::gamma( m_a, m_b ) ),
+ m_floats_in_range( Detail::count_equidistant_floats( m_a, m_b, m_ulp_magnitude ) ),
+ m_int_dist(0, m_floats_in_range),
+ m_max_steps_in_one_go( Detail::calculate_max_steps_in_one_go(m_ulp_magnitude)),
+ m_a_has_leq_magnitude(std::fabs(m_a) <= std::fabs(m_b))
+ {
+ assert( a <= b );
+ }
+
+ template <typename Generator>
+ result_type operator()( Generator& g ) {
+ WidthType steps = m_int_dist( g );
+ if ( m_a_has_leq_magnitude ) {
+ if ( steps == m_floats_in_range ) { return m_a; }
+ auto b = m_b;
+ while (steps > m_max_steps_in_one_go) {
+ b -= m_max_steps_in_one_go * m_ulp_magnitude;
+ steps -= m_max_steps_in_one_go;
+ }
+ return b - steps * m_ulp_magnitude;
+ } else {
+ if ( steps == m_floats_in_range ) { return m_b; }
+ auto a = m_a;
+ while (steps > m_max_steps_in_one_go) {
+ a += m_max_steps_in_one_go * m_ulp_magnitude;
+ steps -= m_max_steps_in_one_go;
+ }
+ return a + steps * m_ulp_magnitude;
+ }
+ }
+
+ result_type a() const { return m_a; }
+ result_type b() const { return m_b; }
+};
+
+} // end namespace Catch
+
+#endif // CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
+
+namespace Catch {
+namespace Generators {
+namespace Detail {
+ // Returns a suitable seed for a random floating generator based off
+ // the primary internal rng. It does so by taking current value from
+ // the rng and returning it as the seed.
+ std::uint32_t getSeed();
+}
+
+template <typename Float>
+class RandomFloatingGenerator final : public IGenerator<Float> {
+ Catch::SimplePcg32 m_rng;
+ Catch::uniform_floating_point_distribution<Float> m_dist;
+ Float m_current_number;
+public:
+ RandomFloatingGenerator( Float a, Float b, std::uint32_t seed ):
+ m_rng(seed),
+ m_dist(a, b) {
+ static_cast<void>(next());
+ }
+
+ Float const& get() const override {
+ return m_current_number;
+ }
+ bool next() override {
+ m_current_number = m_dist(m_rng);
+ return true;
+ }
+};
+
+template <>
+class RandomFloatingGenerator<long double> final : public IGenerator<long double> {
+ // We still rely on <random> for this specialization, but we don't
+ // want to drag it into the header.
+ struct PImpl;
+ Catch::Detail::unique_ptr<PImpl> m_pimpl;
+ long double m_current_number;
+
+public:
+ RandomFloatingGenerator( long double a, long double b, std::uint32_t seed );
+
+ long double const& get() const override { return m_current_number; }
+ bool next() override;
+
+ ~RandomFloatingGenerator() override; // = default
+};
+
+template <typename Integer>
+class RandomIntegerGenerator final : public IGenerator<Integer> {
+ Catch::SimplePcg32 m_rng;
+ Catch::uniform_integer_distribution<Integer> m_dist;
+ Integer m_current_number;
+public:
+ RandomIntegerGenerator( Integer a, Integer b, std::uint32_t seed ):
+ m_rng(seed),
+ m_dist(a, b) {
+ static_cast<void>(next());
+ }
+
+ Integer const& get() const override {
+ return m_current_number;
+ }
+ bool next() override {
+ m_current_number = m_dist(m_rng);
+ return true;
+ }
+};
+
+template <typename T>
+std::enable_if_t<std::is_integral<T>::value, GeneratorWrapper<T>>
+random(T a, T b) {
+ return GeneratorWrapper<T>(
+ Catch::Detail::make_unique<RandomIntegerGenerator<T>>(a, b, Detail::getSeed())
+ );
+}
+
+template <typename T>
+std::enable_if_t<std::is_floating_point<T>::value,
+GeneratorWrapper<T>>
+random(T a, T b) {
+ return GeneratorWrapper<T>(
+ Catch::Detail::make_unique<RandomFloatingGenerator<T>>(a, b, Detail::getSeed())
+ );
+}
+
+
+} // namespace Generators
+} // namespace Catch
+
+
+#endif // CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+
+
+#ifndef CATCH_GENERATORS_RANGE_HPP_INCLUDED
+#define CATCH_GENERATORS_RANGE_HPP_INCLUDED
+
+
+#include <iterator>
+#include <type_traits>
+
+namespace Catch {
+namespace Generators {
+
+
+template <typename T>
+class RangeGenerator final : public IGenerator<T> {
+ T m_current;
+ T m_end;
+ T m_step;
+ bool m_positive;
+
+public:
+ RangeGenerator(T const& start, T const& end, T const& step):
+ m_current(start),
+ m_end(end),
+ m_step(step),
+ m_positive(m_step > T(0))
+ {
+ assert(m_current != m_end && "Range start and end cannot be equal");
+ assert(m_step != T(0) && "Step size cannot be zero");
+ assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
+ }
+
+ RangeGenerator(T const& start, T const& end):
+ RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+ {}
+
+ T const& get() const override {
+ return m_current;
+ }
+
+ bool next() override {
+ m_current += m_step;
+ return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+ }
+};
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
+ static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+ return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end, step));
+}
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end) {
+ static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+ return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end));
+}
+
+
+template <typename T>
+class IteratorGenerator final : public IGenerator<T> {
+ static_assert(!std::is_same<T, bool>::value,
+ "IteratorGenerator currently does not support bools"
+ "because of std::vector<bool> specialization");
+
+ std::vector<T> m_elems;
+ size_t m_current = 0;
+public:
+ template <typename InputIterator, typename InputSentinel>
+ IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
+ if (m_elems.empty()) {
+ Detail::throw_generator_exception("IteratorGenerator received no valid values");
+ }
+ }
+
+ T const& get() const override {
+ return m_elems[m_current];
+ }
+
+ bool next() override {
+ ++m_current;
+ return m_current != m_elems.size();
+ }
+};
+
+template <typename InputIterator,
+ typename InputSentinel,
+ typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
+ return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(from, to));
+}
+
+template <typename Container>
+auto from_range(Container const& cnt) {
+ using std::begin;
+ using std::end;
+ return from_range( begin( cnt ), end( cnt ) );
+}
+
+
+} // namespace Generators
+} // namespace Catch
+
+
+#endif // CATCH_GENERATORS_RANGE_HPP_INCLUDED
+
+#endif // CATCH_GENERATORS_ALL_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's interfaces. It includes
+ * **all** of Catch2 headers related to interfaces.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of somewhat increased compilation
+ * times.
+ *
+ * When a new header is added to either the `interfaces` folder, or to
+ * the corresponding internal subfolder, it should be added here.
+ */
+
+
+#ifndef CATCH_INTERFACES_ALL_HPP_INCLUDED
+#define CATCH_INTERFACES_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+#define CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_RUN_INFO_HPP_INCLUDED
+#define CATCH_TEST_RUN_INFO_HPP_INCLUDED
+
+
+namespace Catch {
+
+ struct TestRunInfo {
+ constexpr TestRunInfo(StringRef _name) : name(_name) {}
+ StringRef name;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_TEST_RUN_INFO_HPP_INCLUDED
+
+#include <map>
+#include <string>
+#include <vector>
+#include <iosfwd>
+
+namespace Catch {
+
+ struct ReporterDescription;
+ struct ListenerDescription;
+ struct TagInfo;
+ struct TestCaseInfo;
+ class TestCaseHandle;
+ class IConfig;
+ class IStream;
+ enum class ColourMode : std::uint8_t;
+
+ struct ReporterConfig {
+ ReporterConfig( IConfig const* _fullConfig,
+ Detail::unique_ptr<IStream> _stream,
+ ColourMode colourMode,
+ std::map<std::string, std::string> customOptions );
+
+ ReporterConfig( ReporterConfig&& ) = default;
+ ReporterConfig& operator=( ReporterConfig&& ) = default;
+ ~ReporterConfig(); // = default
+
+ Detail::unique_ptr<IStream> takeStream() &&;
+ IConfig const* fullConfig() const;
+ ColourMode colourMode() const;
+ std::map<std::string, std::string> const& customOptions() const;
+
+ private:
+ Detail::unique_ptr<IStream> m_stream;
+ IConfig const* m_fullConfig;
+ ColourMode m_colourMode;
+ std::map<std::string, std::string> m_customOptions;
+ };
+
+ struct AssertionStats {
+ AssertionStats( AssertionResult const& _assertionResult,
+ std::vector<MessageInfo> const& _infoMessages,
+ Totals const& _totals );
+
+ AssertionStats( AssertionStats const& ) = default;
+ AssertionStats( AssertionStats && ) = default;
+ AssertionStats& operator = ( AssertionStats const& ) = delete;
+ AssertionStats& operator = ( AssertionStats && ) = delete;
+
+ AssertionResult assertionResult;
+ std::vector<MessageInfo> infoMessages;
+ Totals totals;
+ };
+
+ struct SectionStats {
+ SectionStats( SectionInfo&& _sectionInfo,
+ Counts const& _assertions,
+ double _durationInSeconds,
+ bool _missingAssertions );
+
+ SectionInfo sectionInfo;
+ Counts assertions;
+ double durationInSeconds;
+ bool missingAssertions;
+ };
+
+ struct TestCaseStats {
+ TestCaseStats( TestCaseInfo const& _testInfo,
+ Totals const& _totals,
+ std::string&& _stdOut,
+ std::string&& _stdErr,
+ bool _aborting );
+
+ TestCaseInfo const * testInfo;
+ Totals totals;
+ std::string stdOut;
+ std::string stdErr;
+ bool aborting;
+ };
+
+ struct TestRunStats {
+ TestRunStats( TestRunInfo const& _runInfo,
+ Totals const& _totals,
+ bool _aborting );
+
+ TestRunInfo runInfo;
+ Totals totals;
+ bool aborting;
+ };
+
+ //! By setting up its preferences, a reporter can modify Catch2's behaviour
+ //! in some regards, e.g. it can request Catch2 to capture writes to
+ //! stdout/stderr during test execution, and pass them to the reporter.
+ struct ReporterPreferences {
+ //! Catch2 should redirect writes to stdout and pass them to the
+ //! reporter
+ bool shouldRedirectStdOut = false;
+ //! Catch2 should call `Reporter::assertionEnded` even for passing
+ //! assertions
+ bool shouldReportAllAssertions = false;
+ };
+
+ /**
+ * The common base for all reporters and event listeners
+ *
+ * Implementing classes must also implement:
+ *
+ * //! User-friendly description of the reporter/listener type
+ * static std::string getDescription()
+ *
+ * Generally shouldn't be derived from by users of Catch2 directly,
+ * instead they should derive from one of the utility bases that
+ * derive from this class.
+ */
+ class IEventListener {
+ protected:
+ //! Derived classes can set up their preferences here
+ ReporterPreferences m_preferences;
+ //! The test run's config as filled in from CLI and defaults
+ IConfig const* m_config;
+
+ public:
+ IEventListener( IConfig const* config ): m_config( config ) {}
+
+ virtual ~IEventListener(); // = default;
+
+ // Implementing class must also provide the following static methods:
+ // static std::string getDescription();
+
+ ReporterPreferences const& getPreferences() const {
+ return m_preferences;
+ }
+
+ //! Called when no test cases match provided test spec
+ virtual void noMatchingTestCases( StringRef unmatchedSpec ) = 0;
+ //! Called for all invalid test specs from the cli
+ virtual void reportInvalidTestSpec( StringRef invalidArgument ) = 0;
+
+ /**
+ * Called once in a testing run before tests are started
+ *
+ * Not called if tests won't be run (e.g. only listing will happen)
+ */
+ virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+
+ //! Called _once_ for each TEST_CASE, no matter how many times it is entered
+ virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+ //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
+ virtual void testCasePartialStarting( TestCaseInfo const& testInfo, uint64_t partNumber ) = 0;
+ //! Called when a `SECTION` is being entered. Not called for skipped sections
+ virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+ //! Called when user-code is being probed before the actual benchmark runs
+ virtual void benchmarkPreparing( StringRef benchmarkName ) = 0;
+ //! Called after probe but before the user-code is being benchmarked
+ virtual void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) = 0;
+ //! Called with the benchmark results if benchmark successfully finishes
+ virtual void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) = 0;
+ //! Called if running the benchmarks fails for any reason
+ virtual void benchmarkFailed( StringRef benchmarkName ) = 0;
+
+ //! Called before assertion success/failure is evaluated
+ virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+ //! Called after assertion was fully evaluated
+ virtual void assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+ //! Called after a `SECTION` has finished running
+ virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+ //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
+ virtual void testCasePartialEnded(TestCaseStats const& testCaseStats, uint64_t partNumber ) = 0;
+ //! Called _once_ for each TEST_CASE, no matter how many times it is entered
+ virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+ /**
+ * Called once after all tests in a testing run are finished
+ *
+ * Not called if tests weren't run (e.g. only listings happened)
+ */
+ virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+ /**
+ * Called with test cases that are skipped due to the test run aborting.
+ * NOT called for test cases that are explicitly skipped using the `SKIP` macro.
+ *
+ * Deprecated - will be removed in the next major release.
+ */
+ virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+ //! Called if a fatal error (signal/structured exception) occurred
+ virtual void fatalErrorEncountered( StringRef error ) = 0;
+
+ //! Writes out information about provided reporters using reporter-specific format
+ virtual void listReporters(std::vector<ReporterDescription> const& descriptions) = 0;
+ //! Writes out the provided listeners descriptions using reporter-specific format
+ virtual void listListeners(std::vector<ListenerDescription> const& descriptions) = 0;
+ //! Writes out information about provided tests using reporter-specific format
+ virtual void listTests(std::vector<TestCaseHandle> const& tests) = 0;
+ //! Writes out information about the provided tags using reporter-specific format
+ virtual void listTags(std::vector<TagInfo> const& tags) = 0;
+ };
+ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+
+} // end namespace Catch
+
+#endif // CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+#define CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+ struct ReporterConfig;
+ class IConfig;
+ class IEventListener;
+ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+
+
+ class IReporterFactory {
+ public:
+ virtual ~IReporterFactory(); // = default
+
+ virtual IEventListenerPtr
+ create( ReporterConfig&& config ) const = 0;
+ virtual std::string getDescription() const = 0;
+ };
+ using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+
+ class EventListenerFactory {
+ public:
+ virtual ~EventListenerFactory(); // = default
+ virtual IEventListenerPtr create( IConfig const* config ) const = 0;
+ //! Return a meaningful name for the listener, e.g. its type name
+ virtual StringRef getName() const = 0;
+ //! Return listener's description if available
+ virtual std::string getDescription() const = 0;
+ };
+} // namespace Catch
+
+#endif // CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+#define CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+ struct TagAlias;
+
+ class ITagAliasRegistry {
+ public:
+ virtual ~ITagAliasRegistry(); // = default
+ // Nullptr if not present
+ virtual TagAlias const* find( std::string const& alias ) const = 0;
+ virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+ static ITagAliasRegistry const& get();
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+#define CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+
+ struct TestCaseInfo;
+ class TestCaseHandle;
+ class IConfig;
+
+ class ITestCaseRegistry {
+ public:
+ virtual ~ITestCaseRegistry(); // = default
+ // TODO: this exists only for adding filenames to test cases -- let's expose this in a saner way later
+ virtual std::vector<TestCaseInfo* > const& getAllInfos() const = 0;
+ virtual std::vector<TestCaseHandle> const& getAllTests() const = 0;
+ virtual std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const = 0;
+ };
+
+}
+
+#endif // CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+
+#endif // CATCH_INTERFACES_ALL_HPP_INCLUDED
+
+
+#ifndef CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+#define CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+
+
+namespace Catch {
+ namespace Detail {
+ //! Provides case-insensitive `op<` semantics when called
+ struct CaseInsensitiveLess {
+ bool operator()( StringRef lhs,
+ StringRef rhs ) const;
+ };
+
+ //! Provides case-insensitive `op==` semantics when called
+ struct CaseInsensitiveEqualTo {
+ bool operator()( StringRef lhs,
+ StringRef rhs ) const;
+ };
+
+ } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+
+
+
+/** \file
+ * Wrapper for ANDROID_LOGWRITE configuration option
+ *
+ * We want to default to enabling it when compiled for android, but
+ * users of the library should also be able to disable it if they want
+ * to.
+ */
+
+#ifndef CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+#define CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+
+
+#if defined(__ANDROID__)
+# define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
+#endif
+
+
+#if defined( CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE ) && \
+ !defined( CATCH_CONFIG_NO_ANDROID_LOGWRITE ) && \
+ !defined( CATCH_CONFIG_ANDROID_LOGWRITE )
+# define CATCH_CONFIG_ANDROID_LOGWRITE
+#endif
+
+#endif // CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+
+
+
+/** \file
+ * Wrapper for UNCAUGHT_EXCEPTIONS configuration option
+ *
+ * For some functionality, Catch2 requires to know whether there is
+ * an active exception. Because `std::uncaught_exception` is deprecated
+ * in C++17, we want to use `std::uncaught_exceptions` if possible.
+ */
+
+#ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+#define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+
+#if defined(_MSC_VER)
+# if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+# define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+# endif
+#endif
+
+
+#include <exception>
+
+#if defined(__cpp_lib_uncaught_exceptions) \
+ && !defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+
+# define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif // __cpp_lib_uncaught_exceptions
+
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) \
+ && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) \
+ && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+
+# define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+
+#endif // CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+
+#ifndef CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+#define CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <cstdint>
+
+namespace Catch {
+
+ enum class ColourMode : std::uint8_t;
+ class IStream;
+
+ struct Colour {
+ enum Code {
+ None = 0,
+
+ White,
+ Red,
+ Green,
+ Blue,
+ Cyan,
+ Yellow,
+ Grey,
+
+ Bright = 0x10,
+
+ BrightRed = Bright | Red,
+ BrightGreen = Bright | Green,
+ LightGrey = Bright | Grey,
+ BrightWhite = Bright | White,
+ BrightYellow = Bright | Yellow,
+
+ // By intention
+ FileName = LightGrey,
+ Warning = BrightYellow,
+ ResultError = BrightRed,
+ ResultSuccess = BrightGreen,
+ ResultExpectedFailure = Warning,
+
+ Error = BrightRed,
+ Success = Green,
+ Skip = LightGrey,
+
+ OriginalExpression = Cyan,
+ ReconstructedExpression = BrightYellow,
+
+ SecondaryText = LightGrey,
+ Headers = White
+ };
+ };
+
+ class ColourImpl {
+ protected:
+ //! The associated stream of this ColourImpl instance
+ IStream* m_stream;
+ public:
+ ColourImpl( IStream* stream ): m_stream( stream ) {}
+
+ //! RAII wrapper around writing specific colour of text using specific
+ //! colour impl into a stream.
+ class ColourGuard {
+ ColourImpl const* m_colourImpl;
+ Colour::Code m_code;
+ bool m_engaged = false;
+
+ public:
+ //! Does **not** engage the guard/start the colour
+ ColourGuard( Colour::Code code,
+ ColourImpl const* colour );
+
+ ColourGuard( ColourGuard const& rhs ) = delete;
+ ColourGuard& operator=( ColourGuard const& rhs ) = delete;
+
+ ColourGuard( ColourGuard&& rhs ) noexcept;
+ ColourGuard& operator=( ColourGuard&& rhs ) noexcept;
+
+ //! Removes colour _if_ the guard was engaged
+ ~ColourGuard();
+
+ /**
+ * Explicitly engages colour for given stream.
+ *
+ * The API based on operator<< should be preferred.
+ */
+ ColourGuard& engage( std::ostream& stream ) &;
+ /**
+ * Explicitly engages colour for given stream.
+ *
+ * The API based on operator<< should be preferred.
+ */
+ ColourGuard&& engage( std::ostream& stream ) &&;
+
+ private:
+ //! Engages the guard and starts using colour
+ friend std::ostream& operator<<( std::ostream& lhs,
+ ColourGuard& guard ) {
+ guard.engageImpl( lhs );
+ return lhs;
+ }
+ //! Engages the guard and starts using colour
+ friend std::ostream& operator<<( std::ostream& lhs,
+ ColourGuard&& guard) {
+ guard.engageImpl( lhs );
+ return lhs;
+ }
+
+ void engageImpl( std::ostream& stream );
+
+ };
+
+ virtual ~ColourImpl(); // = default
+ /**
+ * Creates a guard object for given colour and this colour impl
+ *
+ * **Important:**
+ * the guard starts disengaged, and has to be engaged explicitly.
+ */
+ ColourGuard guardColour( Colour::Code colourCode );
+
+ private:
+ virtual void use( Colour::Code colourCode ) const = 0;
+ };
+
+ //! Provides ColourImpl based on global config and target compilation platform
+ Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
+ IStream* stream );
+
+ //! Checks if specific colour impl has been compiled into the binary
+ bool isColourImplAvailable( ColourMode colourSelection );
+
+} // end namespace Catch
+
+#endif // CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+
+
+#ifndef CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+#define CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+
+// This include must be kept so that user's configured value for CONSOLE_WIDTH
+// is used before we attempt to provide a default value
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+#endif // CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+
+
+#ifndef CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+#define CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+
+
+#include <cstddef>
+#include <initializer_list>
+
+// We want a simple polyfill over `std::empty`, `std::size` and so on
+// for C++14 or C++ libraries with incomplete support.
+// We also have to handle that MSVC std lib will happily provide these
+// under older standards.
+#if defined(CATCH_CPP17_OR_GREATER) || defined(_MSC_VER)
+
+// We are already using this header either way, so there shouldn't
+// be much additional overhead in including it to get the feature
+// test macros
+#include <string>
+
+# if !defined(__cpp_lib_nonmember_container_access)
+# define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+# endif
+
+#else
+#define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+#endif
+
+
+
+namespace Catch {
+namespace Detail {
+
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+ template <typename Container>
+ constexpr auto empty(Container const& cont) -> decltype(cont.empty()) {
+ return cont.empty();
+ }
+ template <typename T, std::size_t N>
+ constexpr bool empty(const T (&)[N]) noexcept {
+ // GCC < 7 does not support the const T(&)[] parameter syntax
+ // so we have to ignore the length explicitly
+ (void)N;
+ return false;
+ }
+ template <typename T>
+ constexpr bool empty(std::initializer_list<T> list) noexcept {
+ return list.size() > 0;
+ }
+
+
+ template <typename Container>
+ constexpr auto size(Container const& cont) -> decltype(cont.size()) {
+ return cont.size();
+ }
+ template <typename T, std::size_t N>
+ constexpr std::size_t size(const T(&)[N]) noexcept {
+ return N;
+ }
+#endif // CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+
+} // end namespace Detail
+} // end namespace Catch
+
+
+
+#endif // CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+
+
+#ifndef CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+#define CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+ void writeToDebugConsole( std::string const& text );
+}
+
+#endif // CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+
+
+#ifndef CATCH_DEBUGGER_HPP_INCLUDED
+#define CATCH_DEBUGGER_HPP_INCLUDED
+
+
+namespace Catch {
+ bool isDebuggerActive();
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+ #if defined(__i386__) || defined(__x86_64__)
+ #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+ #elif defined(__aarch64__)
+ #define CATCH_TRAP() __asm__(".inst 0xd43e0000")
+ #elif defined(__POWERPC__)
+ #define CATCH_TRAP() __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
+ : : : "memory","r0","r3","r4" ) /* NOLINT */
+ #endif
+
+#elif defined(CATCH_PLATFORM_IPHONE)
+
+ // use inline assembler
+ #if defined(__i386__) || defined(__x86_64__)
+ #define CATCH_TRAP() __asm__("int $3")
+ #elif defined(__aarch64__)
+ #define CATCH_TRAP() __asm__(".inst 0xd4200000")
+ #elif defined(__arm__) && !defined(__thumb__)
+ #define CATCH_TRAP() __asm__(".inst 0xe7f001f0")
+ #elif defined(__arm__) && defined(__thumb__)
+ #define CATCH_TRAP() __asm__(".inst 0xde01")
+ #endif
+
+#elif defined(CATCH_PLATFORM_LINUX)
+ // If we can use inline assembler, do it because this allows us to break
+ // directly at the location of the failing check instead of breaking inside
+ // raise() called from it, i.e. one stack frame below.
+ #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+ #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
+ #else // Fall back to the generic way.
+ #include <signal.h>
+
+ #define CATCH_TRAP() raise(SIGTRAP)
+ #endif
+#elif defined(_MSC_VER)
+ #define CATCH_TRAP() __debugbreak()
+#elif defined(__MINGW32__)
+ extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+ #define CATCH_TRAP() DebugBreak()
+#endif
+
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+ #ifdef CATCH_TRAP
+ #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+ #else
+ #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+ #endif
+#endif
+
+#endif // CATCH_DEBUGGER_HPP_INCLUDED
+
+
+#ifndef CATCH_ENFORCE_HPP_INCLUDED
+#define CATCH_ENFORCE_HPP_INCLUDED
+
+
+#include <exception>
+
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+ template <typename Ex>
+ [[noreturn]]
+ void throw_exception(Ex const& e) {
+ throw e;
+ }
+#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+ [[noreturn]]
+ void throw_exception(std::exception const& e);
+#endif
+
+ [[noreturn]]
+ void throw_logic_error(std::string const& msg);
+ [[noreturn]]
+ void throw_domain_error(std::string const& msg);
+ [[noreturn]]
+ void throw_runtime_error(std::string const& msg);
+
+} // namespace Catch;
+
+#define CATCH_MAKE_MSG(...) \
+ (Catch::ReusableStringStream() << __VA_ARGS__).str()
+
+#define CATCH_INTERNAL_ERROR(...) \
+ Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
+
+#define CATCH_ERROR(...) \
+ Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_RUNTIME_ERROR(...) \
+ Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_ENFORCE( condition, ... ) \
+ do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
+
+
+#endif // CATCH_ENFORCE_HPP_INCLUDED
+
+
+#ifndef CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+#define CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+
+ namespace Detail {
+
+ Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+
+ class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+
+ std::vector<Catch::Detail::unique_ptr<EnumInfo>> m_enumInfos;
+
+ EnumInfo const& registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values) override;
+ };
+
+ std::vector<StringRef> parseEnums( StringRef enums );
+
+ } // Detail
+
+} // Catch
+
+#endif // CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_ERRNO_GUARD_HPP_INCLUDED
+#define CATCH_ERRNO_GUARD_HPP_INCLUDED
+
+namespace Catch {
+
+ //! Simple RAII class that stores the value of `errno`
+ //! at construction and restores it at destruction.
+ class ErrnoGuard {
+ public:
+ // Keep these outlined to avoid dragging in macros from <cerrno>
+
+ ErrnoGuard();
+ ~ErrnoGuard();
+ private:
+ int m_oldErrno;
+ };
+
+}
+
+#endif // CATCH_ERRNO_GUARD_HPP_INCLUDED
+
+
+#ifndef CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+#define CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+#include <string>
+
+namespace Catch {
+
+ class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+ public:
+ ~ExceptionTranslatorRegistry() override;
+ void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator );
+ std::string translateActiveException() const override;
+
+ private:
+ ExceptionTranslators m_translators;
+ };
+}
+
+#endif // CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+#define CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+
+#include <cassert>
+
+namespace Catch {
+
+ /**
+ * Wrapper for platform-specific fatal error (signals/SEH) handlers
+ *
+ * Tries to be cooperative with other handlers, and not step over
+ * other handlers. This means that unknown structured exceptions
+ * are passed on, previous signal handlers are called, and so on.
+ *
+ * Can only be instantiated once, and assumes that once a signal
+ * is caught, the binary will end up terminating. Thus, there
+ */
+ class FatalConditionHandler {
+ bool m_started = false;
+
+ // Install/disengage implementation for specific platform.
+ // Should be if-defed to work on current platform, can assume
+ // engage-disengage 1:1 pairing.
+ void engage_platform();
+ void disengage_platform() noexcept;
+ public:
+ // Should also have platform-specific implementations as needed
+ FatalConditionHandler();
+ ~FatalConditionHandler();
+
+ void engage() {
+ assert(!m_started && "Handler cannot be installed twice.");
+ m_started = true;
+ engage_platform();
+ }
+
+ void disengage() noexcept {
+ assert(m_started && "Handler cannot be uninstalled without being installed first");
+ m_started = false;
+ disengage_platform();
+ }
+ };
+
+ //! Simple RAII guard for (dis)engaging the FatalConditionHandler
+ class FatalConditionHandlerGuard {
+ FatalConditionHandler* m_handler;
+ public:
+ FatalConditionHandlerGuard(FatalConditionHandler* handler):
+ m_handler(handler) {
+ m_handler->engage();
+ }
+ ~FatalConditionHandlerGuard() {
+ m_handler->disengage();
+ }
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+
+
+#ifndef CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+#define CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <utility>
+#include <limits>
+
+namespace Catch {
+ namespace Detail {
+
+ uint32_t convertToBits(float f);
+ uint64_t convertToBits(double d);
+
+ // Used when we know we want == comparison of two doubles
+ // to centralize warning suppression
+ bool directCompare( float lhs, float rhs );
+ bool directCompare( double lhs, double rhs );
+
+ } // end namespace Detail
+
+
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+# pragma GCC diagnostic push
+ // We do a bunch of direct compensations of floating point numbers,
+ // because we know what we are doing and actually do want the direct
+ // comparison behaviour.
+# pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+
+ /**
+ * Calculates the ULP distance between two floating point numbers
+ *
+ * The ULP distance of two floating point numbers is the count of
+ * valid floating point numbers representable between them.
+ *
+ * There are some exceptions between how this function counts the
+ * distance, and the interpretation of the standard as implemented.
+ * by e.g. `nextafter`. For this function it always holds that:
+ * * `(x == y) => ulpDistance(x, y) == 0` (so `ulpDistance(-0, 0) == 0`)
+ * * `ulpDistance(maxFinite, INF) == 1`
+ * * `ulpDistance(x, -x) == 2 * ulpDistance(x, 0)`
+ *
+ * \pre `!isnan( lhs )`
+ * \pre `!isnan( rhs )`
+ * \pre floating point numbers are represented in IEEE-754 format
+ */
+ template <typename FP>
+ uint64_t ulpDistance( FP lhs, FP rhs ) {
+ assert( std::numeric_limits<FP>::is_iec559 &&
+ "ulpDistance assumes IEEE-754 format for floating point types" );
+ assert( !Catch::isnan( lhs ) &&
+ "Distance between NaN and number is not meaningful" );
+ assert( !Catch::isnan( rhs ) &&
+ "Distance between NaN and number is not meaningful" );
+
+ // We want X == Y to imply 0 ULP distance even if X and Y aren't
+ // bit-equal (-0 and 0), or X - Y != 0 (same sign infinities).
+ if ( lhs == rhs ) { return 0; }
+
+ // We need a properly typed positive zero for type inference.
+ static constexpr FP positive_zero{};
+
+ // We want to ensure that +/- 0 is always represented as positive zero
+ if ( lhs == positive_zero ) { lhs = positive_zero; }
+ if ( rhs == positive_zero ) { rhs = positive_zero; }
+
+ // If arguments have different signs, we can handle them by summing
+ // how far are they from 0 each.
+ if ( std::signbit( lhs ) != std::signbit( rhs ) ) {
+ return ulpDistance( std::abs( lhs ), positive_zero ) +
+ ulpDistance( std::abs( rhs ), positive_zero );
+ }
+
+ // When both lhs and rhs are of the same sign, we can just
+ // read the numbers bitwise as integers, and then subtract them
+ // (assuming IEEE).
+ uint64_t lc = Detail::convertToBits( lhs );
+ uint64_t rc = Detail::convertToBits( rhs );
+
+ // The ulp distance between two numbers is symmetric, so to avoid
+ // dealing with overflows we want the bigger converted number on the lhs
+ if ( lc < rc ) {
+ std::swap( lc, rc );
+ }
+
+ return lc - rc;
+ }
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+# pragma GCC diagnostic pop
+#endif
+
+
+} // end namespace Catch
+
+#endif // CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+
+
+#ifndef CATCH_GETENV_HPP_INCLUDED
+#define CATCH_GETENV_HPP_INCLUDED
+
+namespace Catch {
+namespace Detail {
+
+ //! Wrapper over `std::getenv` that compiles on UWP (and always returns nullptr there)
+ char const* getEnv(char const* varName);
+
+}
+}
+
+#endif // CATCH_GETENV_HPP_INCLUDED
+
+
+#ifndef CATCH_IS_PERMUTATION_HPP_INCLUDED
+#define CATCH_IS_PERMUTATION_HPP_INCLUDED
+
+#include <algorithm>
+#include <iterator>
+
+namespace Catch {
+ namespace Detail {
+
+ template <typename ForwardIter,
+ typename Sentinel,
+ typename T,
+ typename Comparator>
+ ForwardIter find_sentinel( ForwardIter start,
+ Sentinel sentinel,
+ T const& value,
+ Comparator cmp ) {
+ while ( start != sentinel ) {
+ if ( cmp( *start, value ) ) { break; }
+ ++start;
+ }
+ return start;
+ }
+
+ template <typename ForwardIter,
+ typename Sentinel,
+ typename T,
+ typename Comparator>
+ std::ptrdiff_t count_sentinel( ForwardIter start,
+ Sentinel sentinel,
+ T const& value,
+ Comparator cmp ) {
+ std::ptrdiff_t count = 0;
+ while ( start != sentinel ) {
+ if ( cmp( *start, value ) ) { ++count; }
+ ++start;
+ }
+ return count;
+ }
+
+ template <typename ForwardIter, typename Sentinel>
+ std::enable_if_t<!std::is_same<ForwardIter, Sentinel>::value,
+ std::ptrdiff_t>
+ sentinel_distance( ForwardIter iter, const Sentinel sentinel ) {
+ std::ptrdiff_t dist = 0;
+ while ( iter != sentinel ) {
+ ++iter;
+ ++dist;
+ }
+ return dist;
+ }
+
+ template <typename ForwardIter>
+ std::ptrdiff_t sentinel_distance( ForwardIter first,
+ ForwardIter last ) {
+ return std::distance( first, last );
+ }
+
+ template <typename ForwardIter1,
+ typename Sentinel1,
+ typename ForwardIter2,
+ typename Sentinel2,
+ typename Comparator>
+ bool check_element_counts( ForwardIter1 first_1,
+ const Sentinel1 end_1,
+ ForwardIter2 first_2,
+ const Sentinel2 end_2,
+ Comparator cmp ) {
+ auto cursor = first_1;
+ while ( cursor != end_1 ) {
+ if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
+ cursor ) {
+ // we haven't checked this element yet
+ const auto count_in_range_2 =
+ count_sentinel( first_2, end_2, *cursor, cmp );
+ // Not a single instance in 2nd range, so it cannot be a
+ // permutation of 1st range
+ if ( count_in_range_2 == 0 ) { return false; }
+
+ const auto count_in_range_1 =
+ count_sentinel( cursor, end_1, *cursor, cmp );
+ if ( count_in_range_1 != count_in_range_2 ) {
+ return false;
+ }
+ }
+
+ ++cursor;
+ }
+
+ return true;
+ }
+
+ template <typename ForwardIter1,
+ typename Sentinel1,
+ typename ForwardIter2,
+ typename Sentinel2,
+ typename Comparator>
+ bool is_permutation( ForwardIter1 first_1,
+ const Sentinel1 end_1,
+ ForwardIter2 first_2,
+ const Sentinel2 end_2,
+ Comparator cmp ) {
+ // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
+ // TODO: Comparator has to be "both sides", e.g. a == b => b == a
+ // This skips shared prefix of the two ranges
+ while (first_1 != end_1 && first_2 != end_2 && cmp(*first_1, *first_2)) {
+ ++first_1;
+ ++first_2;
+ }
+
+ // We need to handle case where at least one of the ranges has no more elements
+ if (first_1 == end_1 || first_2 == end_2) {
+ return first_1 == end_1 && first_2 == end_2;
+ }
+
+ // pair counting is n**2, so we pay linear walk to compare the sizes first
+ auto dist_1 = sentinel_distance( first_1, end_1 );
+ auto dist_2 = sentinel_distance( first_2, end_2 );
+
+ if (dist_1 != dist_2) { return false; }
+
+ // Since we do not try to handle stronger iterators pair (e.g.
+ // bidir) optimally, the only thing left to do is to check counts in
+ // the remaining ranges.
+ return check_element_counts( first_1, end_1, first_2, end_2, cmp );
+ }
+
+ } // namespace Detail
+} // namespace Catch
+
+#endif // CATCH_IS_PERMUTATION_HPP_INCLUDED
+
+
+#ifndef CATCH_ISTREAM_HPP_INCLUDED
+#define CATCH_ISTREAM_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+#include <string>
+
+namespace Catch {
+
+ class IStream {
+ public:
+ virtual ~IStream(); // = default
+ virtual std::ostream& stream() = 0;
+ /**
+ * Best guess on whether the instance is writing to a console (e.g. via stdout/stderr)
+ *
+ * This is useful for e.g. Win32 colour support, because the Win32
+ * API manipulates console directly, unlike POSIX escape codes,
+ * that can be written anywhere.
+ *
+ * Due to variety of ways to change where the stdout/stderr is
+ * _actually_ being written, users should always assume that
+ * the answer might be wrong.
+ */
+ virtual bool isConsole() const { return false; }
+ };
+
+ /**
+ * Creates a stream wrapper that writes to specific file.
+ *
+ * Also recognizes 4 special filenames
+ * * `-` for stdout
+ * * `%stdout` for stdout
+ * * `%stderr` for stderr
+ * * `%debug` for platform specific debugging output
+ *
+ * \throws if passed an unrecognized %-prefixed stream
+ */
+ auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream>;
+
+}
+
+#endif // CATCH_STREAM_HPP_INCLUDED
+
+
+#ifndef CATCH_JSONWRITER_HPP_INCLUDED
+#define CATCH_JSONWRITER_HPP_INCLUDED
+
+
+#include <cstdint>
+#include <sstream>
+
+namespace Catch {
+ class JsonObjectWriter;
+ class JsonArrayWriter;
+
+ struct JsonUtils {
+ static void indent( std::ostream& os, std::uint64_t level );
+ static void appendCommaNewline( std::ostream& os,
+ bool& should_comma,
+ std::uint64_t level );
+ };
+
+ class JsonValueWriter {
+ public:
+ JsonValueWriter( std::ostream& os );
+ JsonValueWriter( std::ostream& os, std::uint64_t indent_level );
+
+ JsonObjectWriter writeObject() &&;
+ JsonArrayWriter writeArray() &&;
+
+ template <typename T>
+ void write( T const& value ) && {
+ writeImpl( value, !std::is_arithmetic<T>::value );
+ }
+ void write( StringRef value ) &&;
+ void write( bool value ) &&;
+
+ private:
+ void writeImpl( StringRef value, bool quote );
+
+ // Without this SFINAE, this overload is a better match
+ // for `std::string`, `char const*`, `char const[N]` args.
+ // While it would still work, it would cause code bloat
+ // and multiple iteration over the strings
+ template <typename T,
+ typename = typename std::enable_if_t<
+ !std::is_convertible<T, StringRef>::value>>
+ void writeImpl( T const& value, bool quote_value ) {
+ m_sstream << value;
+ writeImpl( m_sstream.str(), quote_value );
+ }
+
+ std::ostream& m_os;
+ std::stringstream m_sstream;
+ std::uint64_t m_indent_level;
+ };
+
+ class JsonObjectWriter {
+ public:
+ JsonObjectWriter( std::ostream& os );
+ JsonObjectWriter( std::ostream& os, std::uint64_t indent_level );
+
+ JsonObjectWriter( JsonObjectWriter&& source ) noexcept;
+ JsonObjectWriter& operator=( JsonObjectWriter&& source ) = delete;
+
+ ~JsonObjectWriter();
+
+ JsonValueWriter write( StringRef key );
+
+ private:
+ std::ostream& m_os;
+ std::uint64_t m_indent_level;
+ bool m_should_comma = false;
+ bool m_active = true;
+ };
+
+ class JsonArrayWriter {
+ public:
+ JsonArrayWriter( std::ostream& os );
+ JsonArrayWriter( std::ostream& os, std::uint64_t indent_level );
+
+ JsonArrayWriter( JsonArrayWriter&& source ) noexcept;
+ JsonArrayWriter& operator=( JsonArrayWriter&& source ) = delete;
+
+ ~JsonArrayWriter();
+
+ JsonObjectWriter writeObject();
+ JsonArrayWriter writeArray();
+
+ template <typename T>
+ JsonArrayWriter& write( T const& value ) {
+ return writeImpl( value );
+ }
+
+ JsonArrayWriter& write( bool value );
+
+ private:
+ template <typename T>
+ JsonArrayWriter& writeImpl( T const& value ) {
+ JsonUtils::appendCommaNewline(
+ m_os, m_should_comma, m_indent_level + 1 );
+ JsonValueWriter{ m_os }.write( value );
+
+ return *this;
+ }
+
+ std::ostream& m_os;
+ std::uint64_t m_indent_level;
+ bool m_should_comma = false;
+ bool m_active = true;
+ };
+
+} // namespace Catch
+
+#endif // CATCH_JSONWRITER_HPP_INCLUDED
+
+
+#ifndef CATCH_LEAK_DETECTOR_HPP_INCLUDED
+#define CATCH_LEAK_DETECTOR_HPP_INCLUDED
+
+namespace Catch {
+
+ struct LeakDetector {
+ LeakDetector();
+ ~LeakDetector();
+ };
+
+}
+#endif // CATCH_LEAK_DETECTOR_HPP_INCLUDED
+
+
+#ifndef CATCH_LIST_HPP_INCLUDED
+#define CATCH_LIST_HPP_INCLUDED
+
+
+#include <set>
+#include <string>
+
+
+namespace Catch {
+
+ class IEventListener;
+ class Config;
+
+
+ struct ReporterDescription {
+ std::string name, description;
+ };
+ struct ListenerDescription {
+ StringRef name;
+ std::string description;
+ };
+
+ struct TagInfo {
+ void add(StringRef spelling);
+ std::string all() const;
+
+ std::set<StringRef> spellings;
+ std::size_t count = 0;
+ };
+
+ bool list( IEventListener& reporter, Config const& config );
+
+} // end namespace Catch
+
+#endif // CATCH_LIST_HPP_INCLUDED
+
+
+#ifndef CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+#define CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+
+
+#include <cstdio>
+#include <iosfwd>
+#include <string>
+
+namespace Catch {
+
+ class RedirectedStream {
+ std::ostream& m_originalStream;
+ std::ostream& m_redirectionStream;
+ std::streambuf* m_prevBuf;
+
+ public:
+ RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
+ ~RedirectedStream();
+ };
+
+ class RedirectedStdOut {
+ ReusableStringStream m_rss;
+ RedirectedStream m_cout;
+ public:
+ RedirectedStdOut();
+ auto str() const -> std::string;
+ };
+
+ // StdErr has two constituent streams in C++, std::cerr and std::clog
+ // This means that we need to redirect 2 streams into 1 to keep proper
+ // order of writes
+ class RedirectedStdErr {
+ ReusableStringStream m_rss;
+ RedirectedStream m_cerr;
+ RedirectedStream m_clog;
+ public:
+ RedirectedStdErr();
+ auto str() const -> std::string;
+ };
+
+ class RedirectedStreams {
+ public:
+ RedirectedStreams(RedirectedStreams const&) = delete;
+ RedirectedStreams& operator=(RedirectedStreams const&) = delete;
+ RedirectedStreams(RedirectedStreams&&) = delete;
+ RedirectedStreams& operator=(RedirectedStreams&&) = delete;
+
+ RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
+ ~RedirectedStreams();
+ private:
+ std::string& m_redirectedCout;
+ std::string& m_redirectedCerr;
+ RedirectedStdOut m_redirectedStdOut;
+ RedirectedStdErr m_redirectedStdErr;
+ };
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+ // Windows's implementation of std::tmpfile is terrible (it tries
+ // to create a file inside system folder, thus requiring elevated
+ // privileges for the binary), so we have to use tmpnam(_s) and
+ // create the file ourselves there.
+ class TempFile {
+ public:
+ TempFile(TempFile const&) = delete;
+ TempFile& operator=(TempFile const&) = delete;
+ TempFile(TempFile&&) = delete;
+ TempFile& operator=(TempFile&&) = delete;
+
+ TempFile();
+ ~TempFile();
+
+ std::FILE* getFile();
+ std::string getContents();
+
+ private:
+ std::FILE* m_file = nullptr;
+ #if defined(_MSC_VER)
+ char m_buffer[L_tmpnam] = { 0 };
+ #endif
+ };
+
+
+ class OutputRedirect {
+ public:
+ OutputRedirect(OutputRedirect const&) = delete;
+ OutputRedirect& operator=(OutputRedirect const&) = delete;
+ OutputRedirect(OutputRedirect&&) = delete;
+ OutputRedirect& operator=(OutputRedirect&&) = delete;
+
+
+ OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
+ ~OutputRedirect();
+
+ private:
+ int m_originalStdout = -1;
+ int m_originalStderr = -1;
+ TempFile m_stdoutFile;
+ TempFile m_stderrFile;
+ std::string& m_stdoutDest;
+ std::string& m_stderrDest;
+ };
+
+#endif
+
+} // end namespace Catch
+
+#endif // CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+
+
+#ifndef CATCH_PARSE_NUMBERS_HPP_INCLUDED
+#define CATCH_PARSE_NUMBERS_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+ /**
+ * Parses unsigned int from the input, using provided base
+ *
+ * Effectively a wrapper around std::stoul but with better error checking
+ * e.g. "-1" is rejected, instead of being parsed as UINT_MAX.
+ */
+ Optional<unsigned int> parseUInt(std::string const& input, int base = 10);
+}
+
+#endif // CATCH_PARSE_NUMBERS_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+#define CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+
+
+#include <map>
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+ class IEventListener;
+ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+ class IReporterFactory;
+ using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+ struct ReporterConfig;
+ class EventListenerFactory;
+
+ class ReporterRegistry {
+ struct ReporterRegistryImpl;
+ Detail::unique_ptr<ReporterRegistryImpl> m_impl;
+
+ public:
+ ReporterRegistry();
+ ~ReporterRegistry(); // = default;
+
+ IEventListenerPtr create( std::string const& name,
+ ReporterConfig&& config ) const;
+
+ void registerReporter( std::string const& name,
+ IReporterFactoryPtr factory );
+
+ void
+ registerListener( Detail::unique_ptr<EventListenerFactory> factory );
+
+ std::map<std::string,
+ IReporterFactoryPtr,
+ Detail::CaseInsensitiveLess> const&
+ getFactories() const;
+
+ std::vector<Detail::unique_ptr<EventListenerFactory>> const&
+ getListeners() const;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_RUN_CONTEXT_HPP_INCLUDED
+#define CATCH_RUN_CONTEXT_HPP_INCLUDED
+
+
+
+#ifndef CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+#define CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace TestCaseTracking {
+
+ struct NameAndLocation {
+ std::string name;
+ SourceLineInfo location;
+
+ NameAndLocation( std::string&& _name, SourceLineInfo const& _location );
+ friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
+ // This is a very cheap check that should have a very high hit rate.
+ // If we get to SourceLineInfo::operator==, we will redo it, but the
+ // cost of repeating is trivial at that point (we will be paying
+ // multiple strcmp/memcmps at that point).
+ if ( lhs.location.line != rhs.location.line ) { return false; }
+ return lhs.name == rhs.name && lhs.location == rhs.location;
+ }
+ friend bool operator!=(NameAndLocation const& lhs,
+ NameAndLocation const& rhs) {
+ return !( lhs == rhs );
+ }
+ };
+
+ /**
+ * This is a variant of `NameAndLocation` that does not own the name string
+ *
+ * This avoids extra allocations when trying to locate a tracker by its
+ * name and location, as long as we make sure that trackers only keep
+ * around the owning variant.
+ */
+ struct NameAndLocationRef {
+ StringRef name;
+ SourceLineInfo location;
+
+ constexpr NameAndLocationRef( StringRef name_,
+ SourceLineInfo location_ ):
+ name( name_ ), location( location_ ) {}
+
+ friend bool operator==( NameAndLocation const& lhs,
+ NameAndLocationRef const& rhs ) {
+ // This is a very cheap check that should have a very high hit rate.
+ // If we get to SourceLineInfo::operator==, we will redo it, but the
+ // cost of repeating is trivial at that point (we will be paying
+ // multiple strcmp/memcmps at that point).
+ if ( lhs.location.line != rhs.location.line ) { return false; }
+ return StringRef( lhs.name ) == rhs.name &&
+ lhs.location == rhs.location;
+ }
+ friend bool operator==( NameAndLocationRef const& lhs,
+ NameAndLocation const& rhs ) {
+ return rhs == lhs;
+ }
+ };
+
+ class ITracker;
+
+ using ITrackerPtr = Catch::Detail::unique_ptr<ITracker>;
+
+ class ITracker {
+ NameAndLocation m_nameAndLocation;
+
+ using Children = std::vector<ITrackerPtr>;
+
+ protected:
+ enum CycleState {
+ NotStarted,
+ Executing,
+ ExecutingChildren,
+ NeedsAnotherRun,
+ CompletedSuccessfully,
+ Failed
+ };
+
+ ITracker* m_parent = nullptr;
+ Children m_children;
+ CycleState m_runState = NotStarted;
+
+ public:
+ ITracker( NameAndLocation&& nameAndLoc, ITracker* parent ):
+ m_nameAndLocation( CATCH_MOVE(nameAndLoc) ),
+ m_parent( parent )
+ {}
+
+
+ // static queries
+ NameAndLocation const& nameAndLocation() const {
+ return m_nameAndLocation;
+ }
+ ITracker* parent() const {
+ return m_parent;
+ }
+
+ virtual ~ITracker(); // = default
+
+
+ // dynamic queries
+
+ //! Returns true if tracker run to completion (successfully or not)
+ virtual bool isComplete() const = 0;
+ //! Returns true if tracker run to completion successfully
+ bool isSuccessfullyCompleted() const {
+ return m_runState == CompletedSuccessfully;
+ }
+ //! Returns true if tracker has started but hasn't been completed
+ bool isOpen() const;
+ //! Returns true iff tracker has started
+ bool hasStarted() const;
+
+ // actions
+ virtual void close() = 0; // Successfully complete
+ virtual void fail() = 0;
+ void markAsNeedingAnotherRun();
+
+ //! Register a nested ITracker
+ void addChild( ITrackerPtr&& child );
+ /**
+ * Returns ptr to specific child if register with this tracker.
+ *
+ * Returns nullptr if not found.
+ */
+ ITracker* findChild( NameAndLocationRef const& nameAndLocation );
+ //! Have any children been added?
+ bool hasChildren() const {
+ return !m_children.empty();
+ }
+
+
+ //! Marks tracker as executing a child, doing se recursively up the tree
+ void openChild();
+
+ /**
+ * Returns true if the instance is a section tracker
+ *
+ * Subclasses should override to true if they are, replaces RTTI
+ * for internal debug checks.
+ */
+ virtual bool isSectionTracker() const;
+ /**
+ * Returns true if the instance is a generator tracker
+ *
+ * Subclasses should override to true if they are, replaces RTTI
+ * for internal debug checks.
+ */
+ virtual bool isGeneratorTracker() const;
+ };
+
+ class TrackerContext {
+
+ enum RunState {
+ NotStarted,
+ Executing,
+ CompletedCycle
+ };
+
+ ITrackerPtr m_rootTracker;
+ ITracker* m_currentTracker = nullptr;
+ RunState m_runState = NotStarted;
+
+ public:
+
+ ITracker& startRun();
+
+ void startCycle() {
+ m_currentTracker = m_rootTracker.get();
+ m_runState = Executing;
+ }
+ void completeCycle();
+
+ bool completedCycle() const;
+ ITracker& currentTracker() { return *m_currentTracker; }
+ void setCurrentTracker( ITracker* tracker );
+ };
+
+ class TrackerBase : public ITracker {
+ protected:
+
+ TrackerContext& m_ctx;
+
+ public:
+ TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+ bool isComplete() const override;
+
+ void open();
+
+ void close() override;
+ void fail() override;
+
+ private:
+ void moveToParent();
+ void moveToThis();
+ };
+
+ class SectionTracker : public TrackerBase {
+ std::vector<StringRef> m_filters;
+ // Note that lifetime-wise we piggy back off the name stored in the `ITracker` parent`.
+ // Currently it allocates owns the name, so this is safe. If it is later refactored
+ // to not own the name, the name still has to outlive the `ITracker` parent, so
+ // this should still be safe.
+ StringRef m_trimmed_name;
+ public:
+ SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+
+ bool isSectionTracker() const override;
+
+ bool isComplete() const override;
+
+ static SectionTracker& acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation );
+
+ void tryOpen();
+
+ void addInitialFilters( std::vector<std::string> const& filters );
+ void addNextFilters( std::vector<StringRef> const& filters );
+ //! Returns filters active in this tracker
+ std::vector<StringRef> const& getFilters() const { return m_filters; }
+ //! Returns whitespace-trimmed name of the tracked section
+ StringRef trimmedName() const;
+ };
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+#endif // CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+ class IGeneratorTracker;
+ class IConfig;
+ class IEventListener;
+ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+
+ ///////////////////////////////////////////////////////////////////////////
+
+ class RunContext final : public IResultCapture {
+
+ public:
+ RunContext( RunContext const& ) = delete;
+ RunContext& operator =( RunContext const& ) = delete;
+
+ explicit RunContext( IConfig const* _config, IEventListenerPtr&& reporter );
+
+ ~RunContext() override;
+
+ Totals runTest(TestCaseHandle const& testCase);
+
+ public: // IResultCapture
+
+ // Assertion handlers
+ void handleExpr
+ ( AssertionInfo const& info,
+ ITransientExpression const& expr,
+ AssertionReaction& reaction ) override;
+ void handleMessage
+ ( AssertionInfo const& info,
+ ResultWas::OfType resultType,
+ StringRef message,
+ AssertionReaction& reaction ) override;
+ void handleUnexpectedExceptionNotThrown
+ ( AssertionInfo const& info,
+ AssertionReaction& reaction ) override;
+ void handleUnexpectedInflightException
+ ( AssertionInfo const& info,
+ std::string&& message,
+ AssertionReaction& reaction ) override;
+ void handleIncomplete
+ ( AssertionInfo const& info ) override;
+ void handleNonExpr
+ ( AssertionInfo const &info,
+ ResultWas::OfType resultType,
+ AssertionReaction &reaction ) override;
+
+ void notifyAssertionStarted( AssertionInfo const& info ) override;
+ bool sectionStarted( StringRef sectionName,
+ SourceLineInfo const& sectionLineInfo,
+ Counts& assertions ) override;
+
+ void sectionEnded( SectionEndInfo&& endInfo ) override;
+ void sectionEndedEarly( SectionEndInfo&& endInfo ) override;
+
+ IGeneratorTracker*
+ acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo ) override;
+ IGeneratorTracker* createGeneratorTracker(
+ StringRef generatorName,
+ SourceLineInfo lineInfo,
+ Generators::GeneratorBasePtr&& generator ) override;
+
+
+ void benchmarkPreparing( StringRef name ) override;
+ void benchmarkStarting( BenchmarkInfo const& info ) override;
+ void benchmarkEnded( BenchmarkStats<> const& stats ) override;
+ void benchmarkFailed( StringRef error ) override;
+
+ void pushScopedMessage( MessageInfo const& message ) override;
+ void popScopedMessage( MessageInfo const& message ) override;
+
+ void emplaceUnscopedMessage( MessageBuilder&& builder ) override;
+
+ std::string getCurrentTestName() const override;
+
+ const AssertionResult* getLastResult() const override;
+
+ void exceptionEarlyReported() override;
+
+ void handleFatalErrorCondition( StringRef message ) override;
+
+ bool lastAssertionPassed() override;
+
+ void assertionPassed() override;
+
+ public:
+ // !TBD We need to do this another way!
+ bool aborting() const;
+
+ private:
+
+ void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
+ void invokeActiveTestCase();
+
+ void resetAssertionInfo();
+ bool testForMissingAssertions( Counts& assertions );
+
+ void assertionEnded( AssertionResult&& result );
+ void reportExpr
+ ( AssertionInfo const &info,
+ ResultWas::OfType resultType,
+ ITransientExpression const *expr,
+ bool negated );
+
+ void populateReaction( AssertionReaction& reaction );
+
+ private:
+
+ void handleUnfinishedSections();
+
+ TestRunInfo m_runInfo;
+ TestCaseHandle const* m_activeTestCase = nullptr;
+ ITracker* m_testCaseTracker = nullptr;
+ Optional<AssertionResult> m_lastResult;
+
+ IConfig const* m_config;
+ Totals m_totals;
+ IEventListenerPtr m_reporter;
+ std::vector<MessageInfo> m_messages;
+ std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
+ AssertionInfo m_lastAssertionInfo;
+ std::vector<SectionEndInfo> m_unfinishedSections;
+ std::vector<ITracker*> m_activeSections;
+ TrackerContext m_trackerContext;
+ FatalConditionHandler m_fatalConditionhandler;
+ bool m_lastAssertionPassed = false;
+ bool m_shouldReportUnexpected = true;
+ bool m_includeSuccessfulResults;
+ };
+
+ void seedRng(IConfig const& config);
+ unsigned int rngSeed();
+} // end namespace Catch
+
+#endif // CATCH_RUN_CONTEXT_HPP_INCLUDED
+
+
+#ifndef CATCH_SHARDING_HPP_INCLUDED
+#define CATCH_SHARDING_HPP_INCLUDED
+
+#include <cassert>
+#include <cmath>
+#include <algorithm>
+
+namespace Catch {
+
+ template<typename Container>
+ Container createShard(Container const& container, std::size_t const shardCount, std::size_t const shardIndex) {
+ assert(shardCount > shardIndex);
+
+ if (shardCount == 1) {
+ return container;
+ }
+
+ const std::size_t totalTestCount = container.size();
+
+ const std::size_t shardSize = totalTestCount / shardCount;
+ const std::size_t leftoverTests = totalTestCount % shardCount;
+
+ const std::size_t startIndex = shardIndex * shardSize + (std::min)(shardIndex, leftoverTests);
+ const std::size_t endIndex = (shardIndex + 1) * shardSize + (std::min)(shardIndex + 1, leftoverTests);
+
+ auto startIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(startIndex));
+ auto endIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(endIndex));
+
+ return Container(startIterator, endIterator);
+ }
+
+}
+
+#endif // CATCH_SHARDING_HPP_INCLUDED
+
+
+#ifndef CATCH_SINGLETONS_HPP_INCLUDED
+#define CATCH_SINGLETONS_HPP_INCLUDED
+
+namespace Catch {
+
+ struct ISingleton {
+ virtual ~ISingleton(); // = default
+ };
+
+
+ void addSingleton( ISingleton* singleton );
+ void cleanupSingletons();
+
+
+ template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
+ class Singleton : SingletonImplT, public ISingleton {
+
+ static auto getInternal() -> Singleton* {
+ static Singleton* s_instance = nullptr;
+ if( !s_instance ) {
+ s_instance = new Singleton;
+ addSingleton( s_instance );
+ }
+ return s_instance;
+ }
+
+ public:
+ static auto get() -> InterfaceT const& {
+ return *getInternal();
+ }
+ static auto getMutable() -> MutableInterfaceT& {
+ return *getInternal();
+ }
+ };
+
+} // namespace Catch
+
+#endif // CATCH_SINGLETONS_HPP_INCLUDED
+
+
+#ifndef CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+#define CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+
+
+#include <vector>
+#include <exception>
+
+namespace Catch {
+
+ class StartupExceptionRegistry {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+ public:
+ void add(std::exception_ptr const& exception) noexcept;
+ std::vector<std::exception_ptr> const& getExceptions() const noexcept;
+ private:
+ std::vector<std::exception_ptr> m_exceptions;
+#endif
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+
+
+
+#ifndef CATCH_STDSTREAMS_HPP_INCLUDED
+#define CATCH_STDSTREAMS_HPP_INCLUDED
+
+#include <iosfwd>
+
+namespace Catch {
+
+ std::ostream& cout();
+ std::ostream& cerr();
+ std::ostream& clog();
+
+} // namespace Catch
+
+#endif
+
+
+#ifndef CATCH_STRING_MANIP_HPP_INCLUDED
+#define CATCH_STRING_MANIP_HPP_INCLUDED
+
+
+#include <cstdint>
+#include <string>
+#include <iosfwd>
+#include <vector>
+
+namespace Catch {
+
+ bool startsWith( std::string const& s, std::string const& prefix );
+ bool startsWith( StringRef s, char prefix );
+ bool endsWith( std::string const& s, std::string const& suffix );
+ bool endsWith( std::string const& s, char suffix );
+ bool contains( std::string const& s, std::string const& infix );
+ void toLowerInPlace( std::string& s );
+ std::string toLower( std::string const& s );
+ char toLower( char c );
+ //! Returns a new string without whitespace at the start/end
+ std::string trim( std::string const& str );
+ //! Returns a substring of the original ref without whitespace. Beware lifetimes!
+ StringRef trim(StringRef ref);
+
+ // !!! Be aware, returns refs into original string - make sure original string outlives them
+ std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
+ bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+
+ /**
+ * Helper for streaming a "count [maybe-plural-of-label]" human-friendly string
+ *
+ * Usage example:
+ * ```cpp
+ * std::cout << "Found " << pluralise(count, "error") << '\n';
+ * ```
+ *
+ * **Important:** The provided string must outlive the instance
+ */
+ class pluralise {
+ std::uint64_t m_count;
+ StringRef m_label;
+
+ public:
+ constexpr pluralise(std::uint64_t count, StringRef label):
+ m_count(count),
+ m_label(label)
+ {}
+
+ friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+ };
+}
+
+#endif // CATCH_STRING_MANIP_HPP_INCLUDED
+
+
+#ifndef CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+#define CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+
+#include <map>
+#include <string>
+
+namespace Catch {
+ struct SourceLineInfo;
+
+ class TagAliasRegistry : public ITagAliasRegistry {
+ public:
+ ~TagAliasRegistry() override;
+ TagAlias const* find( std::string const& alias ) const override;
+ std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
+ void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+
+ private:
+ std::map<std::string, TagAlias> m_registry;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
+#define CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
+
+#include <cstdint>
+
+namespace Catch {
+
+ struct TestCaseInfo;
+
+ class TestCaseInfoHasher {
+ public:
+ using hash_t = std::uint64_t;
+ TestCaseInfoHasher( hash_t seed );
+ uint32_t operator()( TestCaseInfo const& t ) const;
+
+ private:
+ hash_t m_seed;
+ };
+
+} // namespace Catch
+
+#endif /* CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED */
+
+
+#ifndef CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+#define CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+
+
+#include <vector>
+
+namespace Catch {
+
+ class IConfig;
+ class ITestInvoker;
+ class TestCaseHandle;
+ class TestSpec;
+
+ std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases );
+
+ bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config );
+
+ std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config );
+ std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config );
+
+ class TestRegistry : public ITestCaseRegistry {
+ public:
+ void registerTest( Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker );
+
+ std::vector<TestCaseInfo*> const& getAllInfos() const override;
+ std::vector<TestCaseHandle> const& getAllTests() const override;
+ std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const override;
+
+ ~TestRegistry() override; // = default
+
+ private:
+ std::vector<Detail::unique_ptr<TestCaseInfo>> m_owned_test_infos;
+ // Keeps a materialized vector for `getAllInfos`.
+ // We should get rid of that eventually (see interface note)
+ std::vector<TestCaseInfo*> m_viewed_test_infos;
+
+ std::vector<Detail::unique_ptr<ITestInvoker>> m_invokers;
+ std::vector<TestCaseHandle> m_handles;
+ mutable TestRunOrder m_currentSortOrder = TestRunOrder::Declared;
+ mutable std::vector<TestCaseHandle> m_sortedFunctions;
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+
+
+} // end namespace Catch
+
+
+#endif // CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+
+
+#ifndef CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+#define CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+
+#include <vector>
+#include <string>
+
+namespace Catch {
+
+ class ITagAliasRegistry;
+
+ class TestSpecParser {
+ enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+ Mode m_mode = None;
+ Mode lastMode = None;
+ bool m_exclusion = false;
+ std::size_t m_pos = 0;
+ std::size_t m_realPatternPos = 0;
+ std::string m_arg;
+ std::string m_substring;
+ std::string m_patternName;
+ std::vector<std::size_t> m_escapeChars;
+ TestSpec::Filter m_currentFilter;
+ TestSpec m_testSpec;
+ ITagAliasRegistry const* m_tagAliases = nullptr;
+
+ public:
+ TestSpecParser( ITagAliasRegistry const& tagAliases );
+
+ TestSpecParser& parse( std::string const& arg );
+ TestSpec testSpec();
+
+ private:
+ bool visitChar( char c );
+ void startNewMode( Mode mode );
+ bool processNoneChar( char c );
+ void processNameChar( char c );
+ bool processOtherChar( char c );
+ void endMode();
+ void escape();
+ bool isControlChar( char c ) const;
+ void saveLastMode();
+ void revertBackToLastMode();
+ void addFilter();
+ bool separate();
+
+ // Handles common preprocessing of the pattern for name/tag patterns
+ std::string preprocessPattern();
+ // Adds the current pattern as a test name
+ void addNamePattern();
+ // Adds the current pattern as a tag
+ void addTagPattern();
+
+ inline void addCharToPattern(char c) {
+ m_substring += c;
+ m_patternName += c;
+ m_realPatternPos++;
+ }
+
+ };
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+
+
+#ifndef CATCH_TEXTFLOW_HPP_INCLUDED
+#define CATCH_TEXTFLOW_HPP_INCLUDED
+
+
+#include <cassert>
+#include <string>
+#include <vector>
+
+namespace Catch {
+ namespace TextFlow {
+
+ class Columns;
+
+ /**
+ * Abstraction for a string with ansi escape sequences that
+ * automatically skips over escapes when iterating. Only graphical
+ * escape sequences are considered.
+ *
+ * Internal representation:
+ * An escape sequence looks like \033[39;49m
+ * We need bidirectional iteration and the unbound length of escape
+ * sequences poses a problem for operator-- To make this work we'll
+ * replace the last `m` with a 0xff (this is a codepoint that won't have
+ * any utf-8 meaning).
+ */
+ class AnsiSkippingString {
+ std::string m_string;
+ std::size_t m_size = 0;
+
+ // perform 0xff replacement and calculate m_size
+ void preprocessString();
+
+ public:
+ class const_iterator;
+ using iterator = const_iterator;
+ // note: must be u-suffixed or this will cause a "truncation of
+ // constant value" warning on MSVC
+ static constexpr char sentinel = static_cast<char>( 0xffu );
+
+ explicit AnsiSkippingString( std::string const& text );
+ explicit AnsiSkippingString( std::string&& text );
+
+ const_iterator begin() const;
+ const_iterator end() const;
+
+ size_t size() const { return m_size; }
+
+ std::string substring( const_iterator begin,
+ const_iterator end ) const;
+ };
+
+ class AnsiSkippingString::const_iterator {
+ friend AnsiSkippingString;
+ struct EndTag {};
+
+ const std::string* m_string;
+ std::string::const_iterator m_it;
+
+ explicit const_iterator( const std::string& string, EndTag ):
+ m_string( &string ), m_it( string.end() ) {}
+
+ void tryParseAnsiEscapes();
+ void advance();
+ void unadvance();
+
+ public:
+ using difference_type = std::ptrdiff_t;
+ using value_type = char;
+ using pointer = value_type*;
+ using reference = value_type&;
+ using iterator_category = std::bidirectional_iterator_tag;
+
+ explicit const_iterator( const std::string& string ):
+ m_string( &string ), m_it( string.begin() ) {
+ tryParseAnsiEscapes();
+ }
+
+ char operator*() const { return *m_it; }
+
+ const_iterator& operator++() {
+ advance();
+ return *this;
+ }
+ const_iterator operator++( int ) {
+ iterator prev( *this );
+ operator++();
+ return prev;
+ }
+ const_iterator& operator--() {
+ unadvance();
+ return *this;
+ }
+ const_iterator operator--( int ) {
+ iterator prev( *this );
+ operator--();
+ return prev;
+ }
+
+ bool operator==( const_iterator const& other ) const {
+ return m_it == other.m_it;
+ }
+ bool operator!=( const_iterator const& other ) const {
+ return !operator==( other );
+ }
+ bool operator<=( const_iterator const& other ) const {
+ return m_it <= other.m_it;
+ }
+
+ const_iterator oneBefore() const {
+ auto it = *this;
+ return --it;
+ }
+ };
+
+ /**
+ * Represents a column of text with specific width and indentation
+ *
+ * When written out to a stream, it will perform linebreaking
+ * of the provided text so that the written lines fit within
+ * target width.
+ */
+ class Column {
+ // String to be written out
+ AnsiSkippingString m_string;
+ // Width of the column for linebreaking
+ size_t m_width = CATCH_CONFIG_CONSOLE_WIDTH - 1;
+ // Indentation of other lines (including first if initial indent is
+ // unset)
+ size_t m_indent = 0;
+ // Indentation of the first line
+ size_t m_initialIndent = std::string::npos;
+
+ public:
+ /**
+ * Iterates "lines" in `Column` and returns them
+ */
+ class const_iterator {
+ friend Column;
+ struct EndTag {};
+
+ Column const& m_column;
+ // Where does the current line start?
+ AnsiSkippingString::const_iterator m_lineStart;
+ // How long should the current line be?
+ AnsiSkippingString::const_iterator m_lineEnd;
+ // How far have we checked the string to iterate?
+ AnsiSkippingString::const_iterator m_parsedTo;
+ // Should a '-' be appended to the line?
+ bool m_addHyphen = false;
+
+ const_iterator( Column const& column, EndTag ):
+ m_column( column ),
+ m_lineStart( m_column.m_string.end() ),
+ m_lineEnd( column.m_string.end() ),
+ m_parsedTo( column.m_string.end() ) {}
+
+ // Calculates the length of the current line
+ void calcLength();
+
+ // Returns current indentation width
+ size_t indentSize() const;
+
+ // Creates an indented and (optionally) suffixed string from
+ // current iterator position, indentation and length.
+ std::string addIndentAndSuffix(
+ AnsiSkippingString::const_iterator start,
+ AnsiSkippingString::const_iterator end ) const;
+
+ public:
+ using difference_type = std::ptrdiff_t;
+ using value_type = std::string;
+ using pointer = value_type*;
+ using reference = value_type&;
+ using iterator_category = std::forward_iterator_tag;
+
+ explicit const_iterator( Column const& column );
+
+ std::string operator*() const;
+
+ const_iterator& operator++();
+ const_iterator operator++( int );
+
+ bool operator==( const_iterator const& other ) const {
+ return m_lineStart == other.m_lineStart &&
+ &m_column == &other.m_column;
+ }
+ bool operator!=( const_iterator const& other ) const {
+ return !operator==( other );
+ }
+ };
+ using iterator = const_iterator;
+
+ explicit Column( std::string const& text ): m_string( text ) {}
+ explicit Column( std::string&& text ):
+ m_string( CATCH_MOVE( text ) ) {}
+
+ Column& width( size_t newWidth ) & {
+ assert( newWidth > 0 );
+ m_width = newWidth;
+ return *this;
+ }
+ Column&& width( size_t newWidth ) && {
+ assert( newWidth > 0 );
+ m_width = newWidth;
+ return CATCH_MOVE( *this );
+ }
+ Column& indent( size_t newIndent ) & {
+ m_indent = newIndent;
+ return *this;
+ }
+ Column&& indent( size_t newIndent ) && {
+ m_indent = newIndent;
+ return CATCH_MOVE( *this );
+ }
+ Column& initialIndent( size_t newIndent ) & {
+ m_initialIndent = newIndent;
+ return *this;
+ }
+ Column&& initialIndent( size_t newIndent ) && {
+ m_initialIndent = newIndent;
+ return CATCH_MOVE( *this );
+ }
+
+ size_t width() const { return m_width; }
+ const_iterator begin() const { return const_iterator( *this ); }
+ const_iterator end() const {
+ return { *this, const_iterator::EndTag{} };
+ }
+
+ friend std::ostream& operator<<( std::ostream& os,
+ Column const& col );
+
+ friend Columns operator+( Column const& lhs, Column const& rhs );
+ friend Columns operator+( Column&& lhs, Column&& rhs );
+ };
+
+ //! Creates a column that serves as an empty space of specific width
+ Column Spacer( size_t spaceWidth );
+
+ class Columns {
+ std::vector<Column> m_columns;
+
+ public:
+ class iterator {
+ friend Columns;
+ struct EndTag {};
+
+ std::vector<Column> const& m_columns;
+ std::vector<Column::const_iterator> m_iterators;
+ size_t m_activeIterators;
+
+ iterator( Columns const& columns, EndTag );
+
+ public:
+ using difference_type = std::ptrdiff_t;
+ using value_type = std::string;
+ using pointer = value_type*;
+ using reference = value_type&;
+ using iterator_category = std::forward_iterator_tag;
+
+ explicit iterator( Columns const& columns );
+
+ auto operator==( iterator const& other ) const -> bool {
+ return m_iterators == other.m_iterators;
+ }
+ auto operator!=( iterator const& other ) const -> bool {
+ return m_iterators != other.m_iterators;
+ }
+ std::string operator*() const;
+ iterator& operator++();
+ iterator operator++( int );
+ };
+ using const_iterator = iterator;
+
+ iterator begin() const { return iterator( *this ); }
+ iterator end() const { return { *this, iterator::EndTag() }; }
+
+ friend Columns& operator+=( Columns& lhs, Column const& rhs );
+ friend Columns& operator+=( Columns& lhs, Column&& rhs );
+ friend Columns operator+( Columns const& lhs, Column const& rhs );
+ friend Columns operator+( Columns&& lhs, Column&& rhs );
+
+ friend std::ostream& operator<<( std::ostream& os,
+ Columns const& cols );
+ };
+
+ } // namespace TextFlow
+} // namespace Catch
+#endif // CATCH_TEXTFLOW_HPP_INCLUDED
+
+
+#ifndef CATCH_TO_STRING_HPP_INCLUDED
+#define CATCH_TO_STRING_HPP_INCLUDED
+
+#include <string>
+
+
+namespace Catch {
+ template <typename T>
+ std::string to_string(T const& t) {
+#if defined(CATCH_CONFIG_CPP11_TO_STRING)
+ return std::to_string(t);
+#else
+ ReusableStringStream rss;
+ rss << t;
+ return rss.str();
+#endif
+ }
+} // end namespace Catch
+
+#endif // CATCH_TO_STRING_HPP_INCLUDED
+
+
+#ifndef CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+#define CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+namespace Catch {
+ bool uncaught_exceptions();
+} // end namespace Catch
+
+#endif // CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+
+
+#ifndef CATCH_XMLWRITER_HPP_INCLUDED
+#define CATCH_XMLWRITER_HPP_INCLUDED
+
+
+#include <iosfwd>
+#include <vector>
+
+namespace Catch {
+ enum class XmlFormatting {
+ None = 0x00,
+ Indent = 0x01,
+ Newline = 0x02,
+ };
+
+ XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
+ XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
+
+ /**
+ * Helper for XML-encoding text (escaping angle brackets, quotes, etc)
+ *
+ * Note: doesn't take ownership of passed strings, and thus the
+ * encoded string must outlive the encoding instance.
+ */
+ class XmlEncode {
+ public:
+ enum ForWhat { ForTextNodes, ForAttributes };
+
+ XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes );
+
+ void encodeTo( std::ostream& os ) const;
+
+ friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+
+ private:
+ StringRef m_str;
+ ForWhat m_forWhat;
+ };
+
+ class XmlWriter {
+ public:
+
+ class ScopedElement {
+ public:
+ ScopedElement( XmlWriter* writer, XmlFormatting fmt );
+
+ ScopedElement( ScopedElement&& other ) noexcept;
+ ScopedElement& operator=( ScopedElement&& other ) noexcept;
+
+ ~ScopedElement();
+
+ ScopedElement&
+ writeText( StringRef text,
+ XmlFormatting fmt = XmlFormatting::Newline |
+ XmlFormatting::Indent );
+
+ ScopedElement& writeAttribute( StringRef name,
+ StringRef attribute );
+ template <typename T,
+ // Without this SFINAE, this overload is a better match
+ // for `std::string`, `char const*`, `char const[N]` args.
+ // While it would still work, it would cause code bloat
+ // and multiple iteration over the strings
+ typename = typename std::enable_if_t<
+ !std::is_convertible<T, StringRef>::value>>
+ ScopedElement& writeAttribute( StringRef name,
+ T const& attribute ) {
+ m_writer->writeAttribute( name, attribute );
+ return *this;
+ }
+
+ private:
+ XmlWriter* m_writer = nullptr;
+ XmlFormatting m_fmt;
+ };
+
+ XmlWriter( std::ostream& os );
+ ~XmlWriter();
+
+ XmlWriter( XmlWriter const& ) = delete;
+ XmlWriter& operator=( XmlWriter const& ) = delete;
+
+ XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+ ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+ XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+ //! The attribute content is XML-encoded
+ XmlWriter& writeAttribute( StringRef name, StringRef attribute );
+
+ //! Writes the attribute as "true/false"
+ XmlWriter& writeAttribute( StringRef name, bool attribute );
+
+ //! The attribute content is XML-encoded
+ XmlWriter& writeAttribute( StringRef name, char const* attribute );
+
+ //! The attribute value must provide op<<(ostream&, T). The resulting
+ //! serialization is XML-encoded
+ template <typename T,
+ // Without this SFINAE, this overload is a better match
+ // for `std::string`, `char const*`, `char const[N]` args.
+ // While it would still work, it would cause code bloat
+ // and multiple iteration over the strings
+ typename = typename std::enable_if_t<
+ !std::is_convertible<T, StringRef>::value>>
+ XmlWriter& writeAttribute( StringRef name, T const& attribute ) {
+ ReusableStringStream rss;
+ rss << attribute;
+ return writeAttribute( name, rss.str() );
+ }
+
+ //! Writes escaped `text` in a element
+ XmlWriter& writeText( StringRef text,
+ XmlFormatting fmt = XmlFormatting::Newline |
+ XmlFormatting::Indent );
+
+ //! Writes XML comment as "<!-- text -->"
+ XmlWriter& writeComment( StringRef text,
+ XmlFormatting fmt = XmlFormatting::Newline |
+ XmlFormatting::Indent );
+
+ void writeStylesheetRef( StringRef url );
+
+ void ensureTagClosed();
+
+ private:
+
+ void applyFormatting(XmlFormatting fmt);
+
+ void writeDeclaration();
+
+ void newlineIfNecessary();
+
+ bool m_tagIsOpen = false;
+ bool m_needsNewline = false;
+ std::vector<std::string> m_tags;
+ std::string m_indent;
+ std::ostream& m_os;
+ };
+
+}
+
+#endif // CATCH_XMLWRITER_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's Matcher support. It includes
+ * **all** of Catch2 headers related to matchers.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of increased compilation times.
+ *
+ * When a new header is added to either the `matchers` folder, or to
+ * the corresponding internal subfolder, it should be added here.
+ */
+
+#ifndef CATCH_MATCHERS_ALL_HPP_INCLUDED
+#define CATCH_MATCHERS_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_MATCHERS_HPP_INCLUDED
+#define CATCH_MATCHERS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_MATCHERS_IMPL_HPP_INCLUDED
+#define CATCH_MATCHERS_IMPL_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+
+#ifdef __clang__
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wsign-compare"
+# pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#elif defined __GNUC__
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wsign-compare"
+# pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+ template<typename ArgT, typename MatcherT>
+ class MatchExpr : public ITransientExpression {
+ ArgT && m_arg;
+ MatcherT const& m_matcher;
+ public:
+ MatchExpr( ArgT && arg, MatcherT const& matcher )
+ : ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
+ m_arg( CATCH_FORWARD(arg) ),
+ m_matcher( matcher )
+ {}
+
+ void streamReconstructedExpression( std::ostream& os ) const override {
+ os << Catch::Detail::stringify( m_arg )
+ << ' '
+ << m_matcher.toString();
+ }
+ };
+
+#ifdef __clang__
+# pragma clang diagnostic pop
+#elif defined __GNUC__
+# pragma GCC diagnostic pop
+#endif
+
+
+ namespace Matchers {
+ template <typename ArgT>
+ class MatcherBase;
+ }
+
+ using StringMatcher = Matchers::MatcherBase<std::string>;
+
+ void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );
+
+ template<typename ArgT, typename MatcherT>
+ auto makeMatchExpr( ArgT && arg, MatcherT const& matcher ) -> MatchExpr<ArgT, MatcherT> {
+ return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher );
+ }
+
+} // namespace Catch
+
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+ do { \
+ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+ INTERNAL_CATCH_TRY { \
+ catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher ) ); \
+ } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+ } while( false )
+
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
+ do { \
+ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+ if( catchAssertionHandler.allowThrows() ) \
+ try { \
+ static_cast<void>(__VA_ARGS__ ); \
+ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+ } \
+ catch( exceptionType const& ex ) { \
+ catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher ) ); \
+ } \
+ catch( ... ) { \
+ catchAssertionHandler.handleUnexpectedInflightException(); \
+ } \
+ else \
+ catchAssertionHandler.handleThrowingCallSkipped(); \
+ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+ } while( false )
+
+
+#endif // CATCH_MATCHERS_IMPL_HPP_INCLUDED
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace Matchers {
+
+ class MatcherUntypedBase {
+ public:
+ MatcherUntypedBase() = default;
+
+ MatcherUntypedBase(MatcherUntypedBase const&) = default;
+ MatcherUntypedBase(MatcherUntypedBase&&) = default;
+
+ MatcherUntypedBase& operator = (MatcherUntypedBase const&) = delete;
+ MatcherUntypedBase& operator = (MatcherUntypedBase&&) = delete;
+
+ std::string toString() const;
+
+ protected:
+ virtual ~MatcherUntypedBase(); // = default;
+ virtual std::string describe() const = 0;
+ mutable std::string m_cachedToString;
+ };
+
+
+ template<typename T>
+ class MatcherBase : public MatcherUntypedBase {
+ public:
+ virtual bool match( T const& arg ) const = 0;
+ };
+
+ namespace Detail {
+
+ template<typename ArgT>
+ class MatchAllOf final : public MatcherBase<ArgT> {
+ std::vector<MatcherBase<ArgT> const*> m_matchers;
+
+ public:
+ MatchAllOf() = default;
+ MatchAllOf(MatchAllOf const&) = delete;
+ MatchAllOf& operator=(MatchAllOf const&) = delete;
+ MatchAllOf(MatchAllOf&&) = default;
+ MatchAllOf& operator=(MatchAllOf&&) = default;
+
+
+ bool match( ArgT const& arg ) const override {
+ for( auto matcher : m_matchers ) {
+ if (!matcher->match(arg))
+ return false;
+ }
+ return true;
+ }
+ std::string describe() const override {
+ std::string description;
+ description.reserve( 4 + m_matchers.size()*32 );
+ description += "( ";
+ bool first = true;
+ for( auto matcher : m_matchers ) {
+ if( first )
+ first = false;
+ else
+ description += " and ";
+ description += matcher->toString();
+ }
+ description += " )";
+ return description;
+ }
+
+ friend MatchAllOf operator&& (MatchAllOf&& lhs, MatcherBase<ArgT> const& rhs) {
+ lhs.m_matchers.push_back(&rhs);
+ return CATCH_MOVE(lhs);
+ }
+ friend MatchAllOf operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf&& rhs) {
+ rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
+ return CATCH_MOVE(rhs);
+ }
+ };
+
+ //! lvalue overload is intentionally deleted, users should
+ //! not be trying to compose stored composition matchers
+ template<typename ArgT>
+ MatchAllOf<ArgT> operator&& (MatchAllOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
+ //! lvalue overload is intentionally deleted, users should
+ //! not be trying to compose stored composition matchers
+ template<typename ArgT>
+ MatchAllOf<ArgT> operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf<ArgT> const& rhs) = delete;
+
+ template<typename ArgT>
+ class MatchAnyOf final : public MatcherBase<ArgT> {
+ std::vector<MatcherBase<ArgT> const*> m_matchers;
+ public:
+ MatchAnyOf() = default;
+ MatchAnyOf(MatchAnyOf const&) = delete;
+ MatchAnyOf& operator=(MatchAnyOf const&) = delete;
+ MatchAnyOf(MatchAnyOf&&) = default;
+ MatchAnyOf& operator=(MatchAnyOf&&) = default;
+
+ bool match( ArgT const& arg ) const override {
+ for( auto matcher : m_matchers ) {
+ if (matcher->match(arg))
+ return true;
+ }
+ return false;
+ }
+ std::string describe() const override {
+ std::string description;
+ description.reserve( 4 + m_matchers.size()*32 );
+ description += "( ";
+ bool first = true;
+ for( auto matcher : m_matchers ) {
+ if( first )
+ first = false;
+ else
+ description += " or ";
+ description += matcher->toString();
+ }
+ description += " )";
+ return description;
+ }
+
+ friend MatchAnyOf operator|| (MatchAnyOf&& lhs, MatcherBase<ArgT> const& rhs) {
+ lhs.m_matchers.push_back(&rhs);
+ return CATCH_MOVE(lhs);
+ }
+ friend MatchAnyOf operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf&& rhs) {
+ rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
+ return CATCH_MOVE(rhs);
+ }
+ };
+
+ //! lvalue overload is intentionally deleted, users should
+ //! not be trying to compose stored composition matchers
+ template<typename ArgT>
+ MatchAnyOf<ArgT> operator|| (MatchAnyOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
+ //! lvalue overload is intentionally deleted, users should
+ //! not be trying to compose stored composition matchers
+ template<typename ArgT>
+ MatchAnyOf<ArgT> operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf<ArgT> const& rhs) = delete;
+
+ template<typename ArgT>
+ class MatchNotOf final : public MatcherBase<ArgT> {
+ MatcherBase<ArgT> const& m_underlyingMatcher;
+
+ public:
+ explicit MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ):
+ m_underlyingMatcher( underlyingMatcher )
+ {}
+
+ bool match( ArgT const& arg ) const override {
+ return !m_underlyingMatcher.match( arg );
+ }
+
+ std::string describe() const override {
+ return "not " + m_underlyingMatcher.toString();
+ }
+ };
+
+ } // namespace Detail
+
+ template <typename T>
+ Detail::MatchAllOf<T> operator&& (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
+ return Detail::MatchAllOf<T>{} && lhs && rhs;
+ }
+ template <typename T>
+ Detail::MatchAnyOf<T> operator|| (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
+ return Detail::MatchAnyOf<T>{} || lhs || rhs;
+ }
+
+ template <typename T>
+ Detail::MatchNotOf<T> operator! (MatcherBase<T> const& matcher) {
+ return Detail::MatchNotOf<T>{ matcher };
+ }
+
+
+} // namespace Matchers
+} // namespace Catch
+
+
+#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+ #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+ #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+
+ #define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+ #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+
+ #define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+ #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+
+#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+ #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
+ #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+
+ #define CATCH_CHECK_THROWS_WITH( expr, matcher ) (void)(0)
+ #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+
+ #define CATCH_CHECK_THAT( arg, matcher ) (void)(0)
+ #define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+
+ #define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+ #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+
+ #define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+ #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+
+ #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+ #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+
+#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+
+ #define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
+ #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+
+ #define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
+ #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+
+ #define CHECK_THAT( arg, matcher ) (void)(0)
+ #define REQUIRE_THAT( arg, matcher ) (void)(0)
+
+#endif // end of user facing macro declarations
+
+#endif // CATCH_MATCHERS_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+#define CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+
+
+
+#ifndef CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+#define CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+
+
+#include <array>
+#include <algorithm>
+#include <string>
+#include <type_traits>
+
+namespace Catch {
+namespace Matchers {
+ class MatcherGenericBase : public MatcherUntypedBase {
+ public:
+ MatcherGenericBase() = default;
+ ~MatcherGenericBase() override; // = default;
+
+ MatcherGenericBase(MatcherGenericBase const&) = default;
+ MatcherGenericBase(MatcherGenericBase&&) = default;
+
+ MatcherGenericBase& operator=(MatcherGenericBase const&) = delete;
+ MatcherGenericBase& operator=(MatcherGenericBase&&) = delete;
+ };
+
+
+ namespace Detail {
+ template<std::size_t N, std::size_t M>
+ std::array<void const*, N + M> array_cat(std::array<void const*, N> && lhs, std::array<void const*, M> && rhs) {
+ std::array<void const*, N + M> arr{};
+ std::copy_n(lhs.begin(), N, arr.begin());
+ std::copy_n(rhs.begin(), M, arr.begin() + N);
+ return arr;
+ }
+
+ template<std::size_t N>
+ std::array<void const*, N+1> array_cat(std::array<void const*, N> && lhs, void const* rhs) {
+ std::array<void const*, N+1> arr{};
+ std::copy_n(lhs.begin(), N, arr.begin());
+ arr[N] = rhs;
+ return arr;
+ }
+
+ template<std::size_t N>
+ std::array<void const*, N+1> array_cat(void const* lhs, std::array<void const*, N> && rhs) {
+ std::array<void const*, N + 1> arr{ {lhs} };
+ std::copy_n(rhs.begin(), N, arr.begin() + 1);
+ return arr;
+ }
+
+ template<typename T>
+ using is_generic_matcher = std::is_base_of<
+ Catch::Matchers::MatcherGenericBase,
+ std::remove_cv_t<std::remove_reference_t<T>>
+ >;
+
+ template<typename... Ts>
+ using are_generic_matchers = Catch::Detail::conjunction<is_generic_matcher<Ts>...>;
+
+ template<typename T>
+ using is_matcher = std::is_base_of<
+ Catch::Matchers::MatcherUntypedBase,
+ std::remove_cv_t<std::remove_reference_t<T>>
+ >;
+
+
+ template<std::size_t N, typename Arg>
+ bool match_all_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
+ return true;
+ }
+
+ template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
+ bool match_all_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
+ return static_cast<T const*>(matchers[Idx])->match(arg) && match_all_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
+ }
+
+
+ template<std::size_t N, typename Arg>
+ bool match_any_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
+ return false;
+ }
+
+ template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
+ bool match_any_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
+ return static_cast<T const*>(matchers[Idx])->match(arg) || match_any_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
+ }
+
+ std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end);
+
+ template<typename... MatcherTs, std::size_t... Idx>
+ std::string describe_multi_matcher(StringRef combine, std::array<void const*, sizeof...(MatcherTs)> const& matchers, std::index_sequence<Idx...>) {
+ std::array<std::string, sizeof...(MatcherTs)> descriptions {{
+ static_cast<MatcherTs const*>(matchers[Idx])->toString()...
+ }};
+
+ return describe_multi_matcher(combine, descriptions.data(), descriptions.data() + descriptions.size());
+ }
+
+
+ template<typename... MatcherTs>
+ class MatchAllOfGeneric final : public MatcherGenericBase {
+ public:
+ MatchAllOfGeneric(MatchAllOfGeneric const&) = delete;
+ MatchAllOfGeneric& operator=(MatchAllOfGeneric const&) = delete;
+ MatchAllOfGeneric(MatchAllOfGeneric&&) = default;
+ MatchAllOfGeneric& operator=(MatchAllOfGeneric&&) = default;
+
+ MatchAllOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
+ explicit MatchAllOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
+
+ template<typename Arg>
+ bool match(Arg&& arg) const {
+ return match_all_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
+ }
+
+ std::string describe() const override {
+ return describe_multi_matcher<MatcherTs...>(" and "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
+ }
+
+ // Has to be public to enable the concatenating operators
+ // below, because they are not friend of the RHS, only LHS,
+ // and thus cannot access private fields of RHS
+ std::array<void const*, sizeof...( MatcherTs )> m_matchers;
+
+
+ //! Avoids type nesting for `GenericAllOf && GenericAllOf` case
+ template<typename... MatchersRHS>
+ friend
+ MatchAllOfGeneric<MatcherTs..., MatchersRHS...> operator && (
+ MatchAllOfGeneric<MatcherTs...>&& lhs,
+ MatchAllOfGeneric<MatchersRHS...>&& rhs) {
+ return MatchAllOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
+ }
+
+ //! Avoids type nesting for `GenericAllOf && some matcher` case
+ template<typename MatcherRHS>
+ friend std::enable_if_t<is_matcher<MatcherRHS>::value,
+ MatchAllOfGeneric<MatcherTs..., MatcherRHS>> operator && (
+ MatchAllOfGeneric<MatcherTs...>&& lhs,
+ MatcherRHS const& rhs) {
+ return MatchAllOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(&rhs))};
+ }
+
+ //! Avoids type nesting for `some matcher && GenericAllOf` case
+ template<typename MatcherLHS>
+ friend std::enable_if_t<is_matcher<MatcherLHS>::value,
+ MatchAllOfGeneric<MatcherLHS, MatcherTs...>> operator && (
+ MatcherLHS const& lhs,
+ MatchAllOfGeneric<MatcherTs...>&& rhs) {
+ return MatchAllOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
+ }
+ };
+
+
+ template<typename... MatcherTs>
+ class MatchAnyOfGeneric final : public MatcherGenericBase {
+ public:
+ MatchAnyOfGeneric(MatchAnyOfGeneric const&) = delete;
+ MatchAnyOfGeneric& operator=(MatchAnyOfGeneric const&) = delete;
+ MatchAnyOfGeneric(MatchAnyOfGeneric&&) = default;
+ MatchAnyOfGeneric& operator=(MatchAnyOfGeneric&&) = default;
+
+ MatchAnyOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
+ explicit MatchAnyOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
+
+ template<typename Arg>
+ bool match(Arg&& arg) const {
+ return match_any_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
+ }
+
+ std::string describe() const override {
+ return describe_multi_matcher<MatcherTs...>(" or "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
+ }
+
+
+ // Has to be public to enable the concatenating operators
+ // below, because they are not friend of the RHS, only LHS,
+ // and thus cannot access private fields of RHS
+ std::array<void const*, sizeof...( MatcherTs )> m_matchers;
+
+ //! Avoids type nesting for `GenericAnyOf || GenericAnyOf` case
+ template<typename... MatchersRHS>
+ friend MatchAnyOfGeneric<MatcherTs..., MatchersRHS...> operator || (
+ MatchAnyOfGeneric<MatcherTs...>&& lhs,
+ MatchAnyOfGeneric<MatchersRHS...>&& rhs) {
+ return MatchAnyOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
+ }
+
+ //! Avoids type nesting for `GenericAnyOf || some matcher` case
+ template<typename MatcherRHS>
+ friend std::enable_if_t<is_matcher<MatcherRHS>::value,
+ MatchAnyOfGeneric<MatcherTs..., MatcherRHS>> operator || (
+ MatchAnyOfGeneric<MatcherTs...>&& lhs,
+ MatcherRHS const& rhs) {
+ return MatchAnyOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(std::addressof(rhs)))};
+ }
+
+ //! Avoids type nesting for `some matcher || GenericAnyOf` case
+ template<typename MatcherLHS>
+ friend std::enable_if_t<is_matcher<MatcherLHS>::value,
+ MatchAnyOfGeneric<MatcherLHS, MatcherTs...>> operator || (
+ MatcherLHS const& lhs,
+ MatchAnyOfGeneric<MatcherTs...>&& rhs) {
+ return MatchAnyOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
+ }
+ };
+
+
+ template<typename MatcherT>
+ class MatchNotOfGeneric final : public MatcherGenericBase {
+ MatcherT const& m_matcher;
+
+ public:
+ MatchNotOfGeneric(MatchNotOfGeneric const&) = delete;
+ MatchNotOfGeneric& operator=(MatchNotOfGeneric const&) = delete;
+ MatchNotOfGeneric(MatchNotOfGeneric&&) = default;
+ MatchNotOfGeneric& operator=(MatchNotOfGeneric&&) = default;
+
+ explicit MatchNotOfGeneric(MatcherT const& matcher) : m_matcher{matcher} {}
+
+ template<typename Arg>
+ bool match(Arg&& arg) const {
+ return !m_matcher.match(arg);
+ }
+
+ std::string describe() const override {
+ return "not " + m_matcher.toString();
+ }
+
+ //! Negating negation can just unwrap and return underlying matcher
+ friend MatcherT const& operator ! (MatchNotOfGeneric<MatcherT> const& matcher) {
+ return matcher.m_matcher;
+ }
+ };
+ } // namespace Detail
+
+
+ // compose only generic matchers
+ template<typename MatcherLHS, typename MatcherRHS>
+ std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherRHS>>
+ operator && (MatcherLHS const& lhs, MatcherRHS const& rhs) {
+ return { lhs, rhs };
+ }
+
+ template<typename MatcherLHS, typename MatcherRHS>
+ std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherRHS>>
+ operator || (MatcherLHS const& lhs, MatcherRHS const& rhs) {
+ return { lhs, rhs };
+ }
+
+ //! Wrap provided generic matcher in generic negator
+ template<typename MatcherT>
+ std::enable_if_t<Detail::is_generic_matcher<MatcherT>::value, Detail::MatchNotOfGeneric<MatcherT>>
+ operator ! (MatcherT const& matcher) {
+ return Detail::MatchNotOfGeneric<MatcherT>{matcher};
+ }
+
+
+ // compose mixed generic and non-generic matchers
+ template<typename MatcherLHS, typename ArgRHS>
+ std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
+ operator && (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
+ return { lhs, rhs };
+ }
+
+ template<typename ArgLHS, typename MatcherRHS>
+ std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
+ operator && (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
+ return { lhs, rhs };
+ }
+
+ template<typename MatcherLHS, typename ArgRHS>
+ std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
+ operator || (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
+ return { lhs, rhs };
+ }
+
+ template<typename ArgLHS, typename MatcherRHS>
+ std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
+ operator || (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
+ return { lhs, rhs };
+ }
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+
+namespace Catch {
+ namespace Matchers {
+
+ class IsEmptyMatcher final : public MatcherGenericBase {
+ public:
+ template <typename RangeLike>
+ bool match(RangeLike&& rng) const {
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+ using Catch::Detail::empty;
+#else
+ using std::empty;
+#endif
+ return empty(rng);
+ }
+
+ std::string describe() const override;
+ };
+
+ class HasSizeMatcher final : public MatcherGenericBase {
+ std::size_t m_target_size;
+ public:
+ explicit HasSizeMatcher(std::size_t target_size):
+ m_target_size(target_size)
+ {}
+
+ template <typename RangeLike>
+ bool match(RangeLike&& rng) const {
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+ using Catch::Detail::size;
+#else
+ using std::size;
+#endif
+ return size(rng) == m_target_size;
+ }
+
+ std::string describe() const override;
+ };
+
+ template <typename Matcher>
+ class SizeMatchesMatcher final : public MatcherGenericBase {
+ Matcher m_matcher;
+ public:
+ explicit SizeMatchesMatcher(Matcher m):
+ m_matcher(CATCH_MOVE(m))
+ {}
+
+ template <typename RangeLike>
+ bool match(RangeLike&& rng) const {
+#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+ using Catch::Detail::size;
+#else
+ using std::size;
+#endif
+ return m_matcher.match(size(rng));
+ }
+
+ std::string describe() const override {
+ return "size matches " + m_matcher.describe();
+ }
+ };
+
+
+ //! Creates a matcher that accepts empty ranges/containers
+ IsEmptyMatcher IsEmpty();
+ //! Creates a matcher that accepts ranges/containers with specific size
+ HasSizeMatcher SizeIs(std::size_t sz);
+ template <typename Matcher>
+ std::enable_if_t<Detail::is_matcher<Matcher>::value,
+ SizeMatchesMatcher<Matcher>> SizeIs(Matcher&& m) {
+ return SizeMatchesMatcher<Matcher>{CATCH_FORWARD(m)};
+ }
+
+ } // end namespace Matchers
+} // end namespace Catch
+
+#endif // CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+#define CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+
+
+#include <algorithm>
+#include <functional>
+
+namespace Catch {
+ namespace Matchers {
+ //! Matcher for checking that an element in range is equal to specific element
+ template <typename T, typename Equality>
+ class ContainsElementMatcher final : public MatcherGenericBase {
+ T m_desired;
+ Equality m_eq;
+ public:
+ template <typename T2, typename Equality2>
+ ContainsElementMatcher(T2&& target, Equality2&& predicate):
+ m_desired(CATCH_FORWARD(target)),
+ m_eq(CATCH_FORWARD(predicate))
+ {}
+
+ std::string describe() const override {
+ return "contains element " + Catch::Detail::stringify(m_desired);
+ }
+
+ template <typename RangeLike>
+ bool match( RangeLike&& rng ) const {
+ for ( auto&& elem : rng ) {
+ if ( m_eq( elem, m_desired ) ) { return true; }
+ }
+ return false;
+ }
+ };
+
+ //! Meta-matcher for checking that an element in a range matches a specific matcher
+ template <typename Matcher>
+ class ContainsMatcherMatcher final : public MatcherGenericBase {
+ Matcher m_matcher;
+ public:
+ // Note that we do a copy+move to avoid having to SFINAE this
+ // constructor (and also avoid some perfect forwarding failure
+ // cases)
+ ContainsMatcherMatcher(Matcher matcher):
+ m_matcher(CATCH_MOVE(matcher))
+ {}
+
+ template <typename RangeLike>
+ bool match(RangeLike&& rng) const {
+ for (auto&& elem : rng) {
+ if (m_matcher.match(elem)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ std::string describe() const override {
+ return "contains element matching " + m_matcher.describe();
+ }
+ };
+
+ /**
+ * Creates a matcher that checks whether a range contains a specific element.
+ *
+ * Uses `std::equal_to` to do the comparison
+ */
+ template <typename T>
+ std::enable_if_t<!Detail::is_matcher<T>::value,
+ ContainsElementMatcher<T, std::equal_to<>>> Contains(T&& elem) {
+ return { CATCH_FORWARD(elem), std::equal_to<>{} };
+ }
+
+ //! Creates a matcher that checks whether a range contains element matching a matcher
+ template <typename Matcher>
+ std::enable_if_t<Detail::is_matcher<Matcher>::value,
+ ContainsMatcherMatcher<Matcher>> Contains(Matcher&& matcher) {
+ return { CATCH_FORWARD(matcher) };
+ }
+
+ /**
+ * Creates a matcher that checks whether a range contains a specific element.
+ *
+ * Uses `eq` to do the comparisons, the element is provided on the rhs
+ */
+ template <typename T, typename Equality>
+ ContainsElementMatcher<T, Equality> Contains(T&& elem, Equality&& eq) {
+ return { CATCH_FORWARD(elem), CATCH_FORWARD(eq) };
+ }
+
+ }
+}
+
+#endif // CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+#define CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+
+
+namespace Catch {
+namespace Matchers {
+
+class ExceptionMessageMatcher final : public MatcherBase<std::exception> {
+ std::string m_message;
+public:
+
+ ExceptionMessageMatcher(std::string const& message):
+ m_message(message)
+ {}
+
+ bool match(std::exception const& ex) const override;
+
+ std::string describe() const override;
+};
+
+//! Creates a matcher that checks whether a std derived exception has the provided message
+ExceptionMessageMatcher Message(std::string const& message);
+
+template <typename StringMatcherType>
+class ExceptionMessageMatchesMatcher final
+ : public MatcherBase<std::exception> {
+ StringMatcherType m_matcher;
+
+public:
+ ExceptionMessageMatchesMatcher( StringMatcherType matcher ):
+ m_matcher( CATCH_MOVE( matcher ) ) {}
+
+ bool match( std::exception const& ex ) const override {
+ return m_matcher.match( ex.what() );
+ }
+
+ std::string describe() const override {
+ return " matches \"" + m_matcher.describe() + '"';
+ }
+};
+
+//! Creates a matcher that checks whether a message from an std derived
+//! exception matches a provided matcher
+template <typename StringMatcherType>
+ExceptionMessageMatchesMatcher<StringMatcherType>
+MessageMatches( StringMatcherType&& matcher ) {
+ return { CATCH_FORWARD( matcher ) };
+}
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+#define CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+
+
+namespace Catch {
+namespace Matchers {
+
+ namespace Detail {
+ enum class FloatingPointKind : uint8_t;
+ }
+
+ class WithinAbsMatcher final : public MatcherBase<double> {
+ public:
+ WithinAbsMatcher(double target, double margin);
+ bool match(double const& matchee) const override;
+ std::string describe() const override;
+ private:
+ double m_target;
+ double m_margin;
+ };
+
+ //! Creates a matcher that accepts numbers within certain range of target
+ WithinAbsMatcher WithinAbs( double target, double margin );
+
+
+
+ class WithinUlpsMatcher final : public MatcherBase<double> {
+ public:
+ WithinUlpsMatcher( double target,
+ uint64_t ulps,
+ Detail::FloatingPointKind baseType );
+ bool match(double const& matchee) const override;
+ std::string describe() const override;
+ private:
+ double m_target;
+ uint64_t m_ulps;
+ Detail::FloatingPointKind m_type;
+ };
+
+ //! Creates a matcher that accepts doubles within certain ULP range of target
+ WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+ //! Creates a matcher that accepts floats within certain ULP range of target
+ WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+
+
+
+ // Given IEEE-754 format for floats and doubles, we can assume
+ // that float -> double promotion is lossless. Given this, we can
+ // assume that if we do the standard relative comparison of
+ // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
+ // the same result if we do this for floats, as if we do this for
+ // doubles that were promoted from floats.
+ class WithinRelMatcher final : public MatcherBase<double> {
+ public:
+ WithinRelMatcher( double target, double epsilon );
+ bool match(double const& matchee) const override;
+ std::string describe() const override;
+ private:
+ double m_target;
+ double m_epsilon;
+ };
+
+ //! Creates a matcher that accepts doubles within certain relative range of target
+ WithinRelMatcher WithinRel(double target, double eps);
+ //! Creates a matcher that accepts doubles within 100*DBL_EPS relative range of target
+ WithinRelMatcher WithinRel(double target);
+ //! Creates a matcher that accepts doubles within certain relative range of target
+ WithinRelMatcher WithinRel(float target, float eps);
+ //! Creates a matcher that accepts floats within 100*FLT_EPS relative range of target
+ WithinRelMatcher WithinRel(float target);
+
+
+
+ class IsNaNMatcher final : public MatcherBase<double> {
+ public:
+ IsNaNMatcher() = default;
+ bool match( double const& matchee ) const override;
+ std::string describe() const override;
+ };
+
+ IsNaNMatcher IsNaN();
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+#define CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+
+namespace Detail {
+ std::string finalizeDescription(const std::string& desc);
+} // namespace Detail
+
+template <typename T, typename Predicate>
+class PredicateMatcher final : public MatcherBase<T> {
+ Predicate m_predicate;
+ std::string m_description;
+public:
+
+ PredicateMatcher(Predicate&& elem, std::string const& descr)
+ :m_predicate(CATCH_FORWARD(elem)),
+ m_description(Detail::finalizeDescription(descr))
+ {}
+
+ bool match( T const& item ) const override {
+ return m_predicate(item);
+ }
+
+ std::string describe() const override {
+ return m_description;
+ }
+};
+
+ /**
+ * Creates a matcher that calls delegates `match` to the provided predicate.
+ *
+ * The user has to explicitly specify the argument type to the matcher
+ */
+ template<typename T, typename Pred>
+ PredicateMatcher<T, Pred> Predicate(Pred&& predicate, std::string const& description = "") {
+ static_assert(is_callable<Pred(T)>::value, "Predicate not callable with argument T");
+ static_assert(std::is_same<bool, FunctionReturnType<Pred, T>>::value, "Predicate does not return bool");
+ return PredicateMatcher<T, Pred>(CATCH_FORWARD(predicate), description);
+ }
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+#define CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+
+
+namespace Catch {
+ namespace Matchers {
+ // Matcher for checking that all elements in range matches a given matcher.
+ template <typename Matcher>
+ class AllMatchMatcher final : public MatcherGenericBase {
+ Matcher m_matcher;
+ public:
+ AllMatchMatcher(Matcher matcher):
+ m_matcher(CATCH_MOVE(matcher))
+ {}
+
+ std::string describe() const override {
+ return "all match " + m_matcher.describe();
+ }
+
+ template <typename RangeLike>
+ bool match(RangeLike&& rng) const {
+ for (auto&& elem : rng) {
+ if (!m_matcher.match(elem)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ // Matcher for checking that no element in range matches a given matcher.
+ template <typename Matcher>
+ class NoneMatchMatcher final : public MatcherGenericBase {
+ Matcher m_matcher;
+ public:
+ NoneMatchMatcher(Matcher matcher):
+ m_matcher(CATCH_MOVE(matcher))
+ {}
+
+ std::string describe() const override {
+ return "none match " + m_matcher.describe();
+ }
+
+ template <typename RangeLike>
+ bool match(RangeLike&& rng) const {
+ for (auto&& elem : rng) {
+ if (m_matcher.match(elem)) {
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ // Matcher for checking that at least one element in range matches a given matcher.
+ template <typename Matcher>
+ class AnyMatchMatcher final : public MatcherGenericBase {
+ Matcher m_matcher;
+ public:
+ AnyMatchMatcher(Matcher matcher):
+ m_matcher(CATCH_MOVE(matcher))
+ {}
+
+ std::string describe() const override {
+ return "any match " + m_matcher.describe();
+ }
+
+ template <typename RangeLike>
+ bool match(RangeLike&& rng) const {
+ for (auto&& elem : rng) {
+ if (m_matcher.match(elem)) {
+ return true;
+ }
+ }
+ return false;
+ }
+ };
+
+ // Matcher for checking that all elements in range are true.
+ class AllTrueMatcher final : public MatcherGenericBase {
+ public:
+ std::string describe() const override;
+
+ template <typename RangeLike>
+ bool match(RangeLike&& rng) const {
+ for (auto&& elem : rng) {
+ if (!elem) {
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ // Matcher for checking that no element in range is true.
+ class NoneTrueMatcher final : public MatcherGenericBase {
+ public:
+ std::string describe() const override;
+
+ template <typename RangeLike>
+ bool match(RangeLike&& rng) const {
+ for (auto&& elem : rng) {
+ if (elem) {
+ return false;
+ }
+ }
+ return true;
+ }
+ };
+
+ // Matcher for checking that any element in range is true.
+ class AnyTrueMatcher final : public MatcherGenericBase {
+ public:
+ std::string describe() const override;
+
+ template <typename RangeLike>
+ bool match(RangeLike&& rng) const {
+ for (auto&& elem : rng) {
+ if (elem) {
+ return true;
+ }
+ }
+ return false;
+ }
+ };
+
+ // Creates a matcher that checks whether all elements in a range match a matcher
+ template <typename Matcher>
+ AllMatchMatcher<Matcher> AllMatch(Matcher&& matcher) {
+ return { CATCH_FORWARD(matcher) };
+ }
+
+ // Creates a matcher that checks whether no element in a range matches a matcher.
+ template <typename Matcher>
+ NoneMatchMatcher<Matcher> NoneMatch(Matcher&& matcher) {
+ return { CATCH_FORWARD(matcher) };
+ }
+
+ // Creates a matcher that checks whether any element in a range matches a matcher.
+ template <typename Matcher>
+ AnyMatchMatcher<Matcher> AnyMatch(Matcher&& matcher) {
+ return { CATCH_FORWARD(matcher) };
+ }
+
+ // Creates a matcher that checks whether all elements in a range are true
+ AllTrueMatcher AllTrue();
+
+ // Creates a matcher that checks whether no element in a range is true
+ NoneTrueMatcher NoneTrue();
+
+ // Creates a matcher that checks whether any element in a range is true
+ AnyTrueMatcher AnyTrue();
+ }
+}
+
+#endif // CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+#define CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+
+
+#include <algorithm>
+#include <utility>
+
+namespace Catch {
+ namespace Matchers {
+
+ /**
+ * Matcher for checking that an element contains the same
+ * elements in the same order
+ */
+ template <typename TargetRangeLike, typename Equality>
+ class RangeEqualsMatcher final : public MatcherGenericBase {
+ TargetRangeLike m_desired;
+ Equality m_predicate;
+
+ public:
+ template <typename TargetRangeLike2, typename Equality2>
+ RangeEqualsMatcher( TargetRangeLike2&& range,
+ Equality2&& predicate ):
+ m_desired( CATCH_FORWARD( range ) ),
+ m_predicate( CATCH_FORWARD( predicate ) ) {}
+
+ template <typename RangeLike>
+ bool match( RangeLike&& rng ) const {
+ auto rng_start = begin( rng );
+ const auto rng_end = end( rng );
+ auto target_start = begin( m_desired );
+ const auto target_end = end( m_desired );
+
+ while (rng_start != rng_end && target_start != target_end) {
+ if (!m_predicate(*rng_start, *target_start)) {
+ return false;
+ }
+ ++rng_start;
+ ++target_start;
+ }
+ return rng_start == rng_end && target_start == target_end;
+ }
+
+ std::string describe() const override {
+ return "elements are " + Catch::Detail::stringify( m_desired );
+ }
+ };
+
+ /**
+ * Matcher for checking that an element contains the same
+ * elements (but not necessarily in the same order)
+ */
+ template <typename TargetRangeLike, typename Equality>
+ class UnorderedRangeEqualsMatcher final : public MatcherGenericBase {
+ TargetRangeLike m_desired;
+ Equality m_predicate;
+
+ public:
+ template <typename TargetRangeLike2, typename Equality2>
+ UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
+ Equality2&& predicate ):
+ m_desired( CATCH_FORWARD( range ) ),
+ m_predicate( CATCH_FORWARD( predicate ) ) {}
+
+ template <typename RangeLike>
+ bool match( RangeLike&& rng ) const {
+ using std::begin;
+ using std::end;
+ return Catch::Detail::is_permutation( begin( m_desired ),
+ end( m_desired ),
+ begin( rng ),
+ end( rng ),
+ m_predicate );
+ }
+
+ std::string describe() const override {
+ return "unordered elements are " +
+ ::Catch::Detail::stringify( m_desired );
+ }
+ };
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range.
+ *
+ * Uses `std::equal_to` to do the comparison
+ */
+ template <typename RangeLike>
+ std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
+ RangeEqualsMatcher<RangeLike, std::equal_to<>>>
+ RangeEquals( RangeLike&& range ) {
+ return { CATCH_FORWARD( range ), std::equal_to<>{} };
+ }
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range.
+ *
+ * Uses to provided predicate `predicate` to do the comparisons
+ */
+ template <typename RangeLike, typename Equality>
+ RangeEqualsMatcher<RangeLike, Equality>
+ RangeEquals( RangeLike&& range, Equality&& predicate ) {
+ return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
+ }
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range, in some permutation
+ *
+ * Uses `std::equal_to` to do the comparison
+ */
+ template <typename RangeLike>
+ std::enable_if_t<
+ !Detail::is_matcher<RangeLike>::value,
+ UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
+ UnorderedRangeEquals( RangeLike&& range ) {
+ return { CATCH_FORWARD( range ), std::equal_to<>{} };
+ }
+
+ /**
+ * Creates a matcher that checks if all elements in a range are equal
+ * to all elements in another range, in some permutation.
+ *
+ * Uses to provided predicate `predicate` to do the comparisons
+ */
+ template <typename RangeLike, typename Equality>
+ UnorderedRangeEqualsMatcher<RangeLike, Equality>
+ UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
+ return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
+ }
+ } // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_STRING_HPP_INCLUDED
+#define CATCH_MATCHERS_STRING_HPP_INCLUDED
+
+
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+
+ struct CasedString {
+ CasedString( std::string const& str, CaseSensitive caseSensitivity );
+ std::string adjustString( std::string const& str ) const;
+ StringRef caseSensitivitySuffix() const;
+
+ CaseSensitive m_caseSensitivity;
+ std::string m_str;
+ };
+
+ class StringMatcherBase : public MatcherBase<std::string> {
+ protected:
+ CasedString m_comparator;
+ StringRef m_operation;
+
+ public:
+ StringMatcherBase( StringRef operation,
+ CasedString const& comparator );
+ std::string describe() const override;
+ };
+
+ class StringEqualsMatcher final : public StringMatcherBase {
+ public:
+ StringEqualsMatcher( CasedString const& comparator );
+ bool match( std::string const& source ) const override;
+ };
+ class StringContainsMatcher final : public StringMatcherBase {
+ public:
+ StringContainsMatcher( CasedString const& comparator );
+ bool match( std::string const& source ) const override;
+ };
+ class StartsWithMatcher final : public StringMatcherBase {
+ public:
+ StartsWithMatcher( CasedString const& comparator );
+ bool match( std::string const& source ) const override;
+ };
+ class EndsWithMatcher final : public StringMatcherBase {
+ public:
+ EndsWithMatcher( CasedString const& comparator );
+ bool match( std::string const& source ) const override;
+ };
+
+ class RegexMatcher final : public MatcherBase<std::string> {
+ std::string m_regex;
+ CaseSensitive m_caseSensitivity;
+
+ public:
+ RegexMatcher( std::string regex, CaseSensitive caseSensitivity );
+ bool match( std::string const& matchee ) const override;
+ std::string describe() const override;
+ };
+
+ //! Creates matcher that accepts strings that are exactly equal to `str`
+ StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+ //! Creates matcher that accepts strings that contain `str`
+ StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+ //! Creates matcher that accepts strings that _end_ with `str`
+ EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+ //! Creates matcher that accepts strings that _start_ with `str`
+ StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+ //! Creates matcher that accepts strings matching `regex`
+ RegexMatcher Matches( std::string const& regex, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_STRING_HPP_INCLUDED
+
+
+#ifndef CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+#define CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+
+
+#include <algorithm>
+
+namespace Catch {
+namespace Matchers {
+
+ template<typename T, typename Alloc>
+ class VectorContainsElementMatcher final : public MatcherBase<std::vector<T, Alloc>> {
+ T const& m_comparator;
+
+ public:
+ VectorContainsElementMatcher(T const& comparator):
+ m_comparator(comparator)
+ {}
+
+ bool match(std::vector<T, Alloc> const& v) const override {
+ for (auto const& el : v) {
+ if (el == m_comparator) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ std::string describe() const override {
+ return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+ }
+ };
+
+ template<typename T, typename AllocComp, typename AllocMatch>
+ class ContainsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+ std::vector<T, AllocComp> const& m_comparator;
+
+ public:
+ ContainsMatcher(std::vector<T, AllocComp> const& comparator):
+ m_comparator( comparator )
+ {}
+
+ bool match(std::vector<T, AllocMatch> const& v) const override {
+ // !TBD: see note in EqualsMatcher
+ if (m_comparator.size() > v.size())
+ return false;
+ for (auto const& comparator : m_comparator) {
+ auto present = false;
+ for (const auto& el : v) {
+ if (el == comparator) {
+ present = true;
+ break;
+ }
+ }
+ if (!present) {
+ return false;
+ }
+ }
+ return true;
+ }
+ std::string describe() const override {
+ return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+ }
+ };
+
+ template<typename T, typename AllocComp, typename AllocMatch>
+ class EqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+ std::vector<T, AllocComp> const& m_comparator;
+
+ public:
+ EqualsMatcher(std::vector<T, AllocComp> const& comparator):
+ m_comparator( comparator )
+ {}
+
+ bool match(std::vector<T, AllocMatch> const& v) const override {
+ // !TBD: This currently works if all elements can be compared using !=
+ // - a more general approach would be via a compare template that defaults
+ // to using !=. but could be specialised for, e.g. std::vector<T> etc
+ // - then just call that directly
+ if ( m_comparator.size() != v.size() ) { return false; }
+ for ( std::size_t i = 0; i < v.size(); ++i ) {
+ if ( !( m_comparator[i] == v[i] ) ) { return false; }
+ }
+ return true;
+ }
+ std::string describe() const override {
+ return "Equals: " + ::Catch::Detail::stringify( m_comparator );
+ }
+ };
+
+ template<typename T, typename AllocComp, typename AllocMatch>
+ class ApproxMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+ std::vector<T, AllocComp> const& m_comparator;
+ mutable Catch::Approx approx = Catch::Approx::custom();
+
+ public:
+ ApproxMatcher(std::vector<T, AllocComp> const& comparator):
+ m_comparator( comparator )
+ {}
+
+ bool match(std::vector<T, AllocMatch> const& v) const override {
+ if (m_comparator.size() != v.size())
+ return false;
+ for (std::size_t i = 0; i < v.size(); ++i)
+ if (m_comparator[i] != approx(v[i]))
+ return false;
+ return true;
+ }
+ std::string describe() const override {
+ return "is approx: " + ::Catch::Detail::stringify( m_comparator );
+ }
+ template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ ApproxMatcher& epsilon( T const& newEpsilon ) {
+ approx.epsilon(static_cast<double>(newEpsilon));
+ return *this;
+ }
+ template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ ApproxMatcher& margin( T const& newMargin ) {
+ approx.margin(static_cast<double>(newMargin));
+ return *this;
+ }
+ template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+ ApproxMatcher& scale( T const& newScale ) {
+ approx.scale(static_cast<double>(newScale));
+ return *this;
+ }
+ };
+
+ template<typename T, typename AllocComp, typename AllocMatch>
+ class UnorderedEqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+ std::vector<T, AllocComp> const& m_target;
+
+ public:
+ UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target):
+ m_target(target)
+ {}
+ bool match(std::vector<T, AllocMatch> const& vec) const override {
+ if (m_target.size() != vec.size()) {
+ return false;
+ }
+ return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+ }
+
+ std::string describe() const override {
+ return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
+ }
+ };
+
+
+ // The following functions create the actual matcher objects.
+ // This allows the types to be inferred
+
+ //! Creates a matcher that matches vectors that contain all elements in `comparator`
+ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+ ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vector<T, AllocComp> const& comparator ) {
+ return ContainsMatcher<T, AllocComp, AllocMatch>(comparator);
+ }
+
+ //! Creates a matcher that matches vectors that contain `comparator` as an element
+ template<typename T, typename Alloc = std::allocator<T>>
+ VectorContainsElementMatcher<T, Alloc> VectorContains( T const& comparator ) {
+ return VectorContainsElementMatcher<T, Alloc>(comparator);
+ }
+
+ //! Creates a matcher that matches vectors that are exactly equal to `comparator`
+ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+ EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<T, AllocComp> const& comparator ) {
+ return EqualsMatcher<T, AllocComp, AllocMatch>(comparator);
+ }
+
+ //! Creates a matcher that matches vectors that `comparator` as an element
+ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+ ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<T, AllocComp> const& comparator ) {
+ return ApproxMatcher<T, AllocComp, AllocMatch>(comparator);
+ }
+
+ //! Creates a matcher that matches vectors that is equal to `target` modulo permutation
+ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+ UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEquals(std::vector<T, AllocComp> const& target) {
+ return UnorderedEqualsMatcher<T, AllocComp, AllocMatch>(target);
+ }
+
+} // namespace Matchers
+} // namespace Catch
+
+#endif // CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+
+#endif // CATCH_MATCHERS_ALL_HPP_INCLUDED
+
+
+/** \file
+ * This is a convenience header for Catch2's Reporter support. It includes
+ * **all** of Catch2 headers related to reporters, including all reporters.
+ *
+ * Generally the Catch2 users should use specific includes they need,
+ * but this header can be used instead for ease-of-experimentation, or
+ * just plain convenience, at the cost of (significantly) increased
+ * compilation times.
+ *
+ * When a new header (reporter) is added to either the `reporter` folder,
+ * or to the corresponding internal subfolder, it should be added here.
+ */
+
+#ifndef CATCH_REPORTERS_ALL_HPP_INCLUDED
+#define CATCH_REPORTERS_ALL_HPP_INCLUDED
+
+
+
+#ifndef CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+#define CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+
+
+
+#ifndef CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+#define CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+
+
+
+#ifndef CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+#define CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+
+
+#include <map>
+#include <string>
+
+namespace Catch {
+ class ColourImpl;
+
+ /**
+ * This is the base class for all reporters.
+ *
+ * If are writing a reporter, you must derive from this type, or one
+ * of the helper reporter bases that are derived from this type.
+ *
+ * ReporterBase centralizes handling of various common tasks in reporters,
+ * like storing the right stream for the reporters to write to, and
+ * providing the default implementation of the different listing events.
+ */
+ class ReporterBase : public IEventListener {
+ protected:
+ //! The stream wrapper as passed to us by outside code
+ Detail::unique_ptr<IStream> m_wrapped_stream;
+ //! Cached output stream from `m_wrapped_stream` to reduce
+ //! number of indirect calls needed to write output.
+ std::ostream& m_stream;
+ //! Colour implementation this reporter was configured for
+ Detail::unique_ptr<ColourImpl> m_colour;
+ //! The custom reporter options user passed down to the reporter
+ std::map<std::string, std::string> m_customOptions;
+
+ public:
+ ReporterBase( ReporterConfig&& config );
+ ~ReporterBase() override; // = default;
+
+ /**
+ * Provides a simple default listing of reporters.
+ *
+ * Should look roughly like the reporter listing in v2 and earlier
+ * versions of Catch2.
+ */
+ void listReporters(
+ std::vector<ReporterDescription> const& descriptions ) override;
+ /**
+ * Provides a simple default listing of listeners
+ *
+ * Looks similarly to listing of reporters, but with listener type
+ * instead of reporter name.
+ */
+ void listListeners(
+ std::vector<ListenerDescription> const& descriptions ) override;
+ /**
+ * Provides a simple default listing of tests.
+ *
+ * Should look roughly like the test listing in v2 and earlier versions
+ * of Catch2. Especially supports low-verbosity listing that mimics the
+ * old `--list-test-names-only` output.
+ */
+ void listTests( std::vector<TestCaseHandle> const& tests ) override;
+ /**
+ * Provides a simple default listing of tags.
+ *
+ * Should look roughly like the tag listing in v2 and earlier versions
+ * of Catch2.
+ */
+ void listTags( std::vector<TagInfo> const& tags ) override;
+ };
+} // namespace Catch
+
+#endif // CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+
+#include <vector>
+
+namespace Catch {
+
+ class StreamingReporterBase : public ReporterBase {
+ public:
+ // GCC5 compat: we cannot use inherited constructor, because it
+ // doesn't implement backport of P0136
+ StreamingReporterBase(ReporterConfig&& _config):
+ ReporterBase(CATCH_MOVE(_config))
+ {}
+ ~StreamingReporterBase() override;
+
+ void benchmarkPreparing( StringRef ) override {}
+ void benchmarkStarting( BenchmarkInfo const& ) override {}
+ void benchmarkEnded( BenchmarkStats<> const& ) override {}
+ void benchmarkFailed( StringRef ) override {}
+
+ void fatalErrorEncountered( StringRef /*error*/ ) override {}
+ void noMatchingTestCases( StringRef /*unmatchedSpec*/ ) override {}
+ void reportInvalidTestSpec( StringRef /*invalidArgument*/ ) override {}
+
+ void testRunStarting( TestRunInfo const& _testRunInfo ) override;
+
+ void testCaseStarting(TestCaseInfo const& _testInfo) override {
+ currentTestCaseInfo = &_testInfo;
+ }
+ void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
+ void sectionStarting(SectionInfo const& _sectionInfo) override {
+ m_sectionStack.push_back(_sectionInfo);
+ }
+
+ void assertionStarting( AssertionInfo const& ) override {}
+ void assertionEnded( AssertionStats const& ) override {}
+
+ void sectionEnded(SectionStats const& /* _sectionStats */) override {
+ m_sectionStack.pop_back();
+ }
+ void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
+ void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+ currentTestCaseInfo = nullptr;
+ }
+ void testRunEnded( TestRunStats const& /* _testRunStats */ ) override;
+
+ void skipTest(TestCaseInfo const&) override {
+ // Don't do anything with this by default.
+ // It can optionally be overridden in the derived class.
+ }
+
+ protected:
+ TestRunInfo currentTestRunInfo{ "test run has not started yet"_sr };
+ TestCaseInfo const* currentTestCaseInfo = nullptr;
+
+ //! Stack of all _active_ sections in the _current_ test case
+ std::vector<SectionInfo> m_sectionStack;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+
+#include <string>
+
+namespace Catch {
+
+ class AutomakeReporter final : public StreamingReporterBase {
+ public:
+ // GCC5 compat: we cannot use inherited constructor, because it
+ // doesn't implement backport of P0136
+ AutomakeReporter(ReporterConfig&& _config):
+ StreamingReporterBase(CATCH_MOVE(_config))
+ {}
+ ~AutomakeReporter() override;
+
+ static std::string getDescription() {
+ using namespace std::string_literals;
+ return "Reports test results in the format of Automake .trs files"s;
+ }
+
+ void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+ void skipTest(TestCaseInfo const& testInfo) override;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_COMPACT_HPP_INCLUDED
+#define CATCH_REPORTER_COMPACT_HPP_INCLUDED
+
+
+
+
+namespace Catch {
+
+ class CompactReporter final : public StreamingReporterBase {
+ public:
+ using StreamingReporterBase::StreamingReporterBase;
+
+ ~CompactReporter() override;
+
+ static std::string getDescription();
+
+ void noMatchingTestCases( StringRef unmatchedSpec ) override;
+
+ void testRunStarting( TestRunInfo const& _testInfo ) override;
+
+ void assertionEnded(AssertionStats const& _assertionStats) override;
+
+ void sectionEnded(SectionStats const& _sectionStats) override;
+
+ void testRunEnded(TestRunStats const& _testRunStats) override;
+
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_COMPACT_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+#define CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+
+namespace Catch {
+ // Fwd decls
+ class TablePrinter;
+
+ class ConsoleReporter final : public StreamingReporterBase {
+ Detail::unique_ptr<TablePrinter> m_tablePrinter;
+
+ public:
+ ConsoleReporter(ReporterConfig&& config);
+ ~ConsoleReporter() override;
+ static std::string getDescription();
+
+ void noMatchingTestCases( StringRef unmatchedSpec ) override;
+ void reportInvalidTestSpec( StringRef arg ) override;
+
+ void assertionStarting(AssertionInfo const&) override;
+
+ void assertionEnded(AssertionStats const& _assertionStats) override;
+
+ void sectionStarting(SectionInfo const& _sectionInfo) override;
+ void sectionEnded(SectionStats const& _sectionStats) override;
+
+ void benchmarkPreparing( StringRef name ) override;
+ void benchmarkStarting(BenchmarkInfo const& info) override;
+ void benchmarkEnded(BenchmarkStats<> const& stats) override;
+ void benchmarkFailed( StringRef error ) override;
+
+ void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+ void testRunEnded(TestRunStats const& _testRunStats) override;
+ void testRunStarting(TestRunInfo const& _testRunInfo) override;
+
+ private:
+ void lazyPrint();
+
+ void lazyPrintWithoutClosingBenchmarkTable();
+ void lazyPrintRunInfo();
+ void printTestCaseAndSectionHeader();
+
+ void printClosedHeader(std::string const& _name);
+ void printOpenHeader(std::string const& _name);
+
+ // if string has a : in first line will set indent to follow it on
+ // subsequent lines
+ void printHeaderString(std::string const& _string, std::size_t indent = 0);
+
+ void printTotalsDivider(Totals const& totals);
+
+ bool m_headerPrinted = false;
+ bool m_testRunInfoPrinted = false;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+#define CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+
+ namespace Detail {
+
+ //! Represents either an assertion or a benchmark result to be handled by cumulative reporter later
+ class AssertionOrBenchmarkResult {
+ // This should really be a variant, but this is much faster
+ // to write and the data layout here is already terrible
+ // enough that we do not have to care about the object size.
+ Optional<AssertionStats> m_assertion;
+ Optional<BenchmarkStats<>> m_benchmark;
+ public:
+ AssertionOrBenchmarkResult(AssertionStats const& assertion);
+ AssertionOrBenchmarkResult(BenchmarkStats<> const& benchmark);
+
+ bool isAssertion() const;
+ bool isBenchmark() const;
+
+ AssertionStats const& asAssertion() const;
+ BenchmarkStats<> const& asBenchmark() const;
+ };
+ }
+
+ /**
+ * Utility base for reporters that need to handle all results at once
+ *
+ * It stores tree of all test cases, sections and assertions, and after the
+ * test run is finished, calls into `testRunEndedCumulative` to pass the
+ * control to the deriving class.
+ *
+ * If you are deriving from this class and override any testing related
+ * member functions, you should first call into the base's implementation to
+ * avoid breaking the tree construction.
+ *
+ * Due to the way this base functions, it has to expand assertions up-front,
+ * even if they are later unused (e.g. because the deriving reporter does
+ * not report successful assertions, or because the deriving reporter does
+ * not use assertion expansion at all). Derived classes can use two
+ * customization points, `m_shouldStoreSuccesfulAssertions` and
+ * `m_shouldStoreFailedAssertions`, to disable the expansion and gain extra
+ * performance. **Accessing the assertion expansions if it wasn't stored is
+ * UB.**
+ */
+ class CumulativeReporterBase : public ReporterBase {
+ public:
+ template<typename T, typename ChildNodeT>
+ struct Node {
+ explicit Node( T const& _value ) : value( _value ) {}
+
+ using ChildNodes = std::vector<Detail::unique_ptr<ChildNodeT>>;
+ T value;
+ ChildNodes children;
+ };
+ struct SectionNode {
+ explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+
+ bool operator == (SectionNode const& other) const {
+ return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+ }
+
+ bool hasAnyAssertions() const;
+
+ SectionStats stats;
+ std::vector<Detail::unique_ptr<SectionNode>> childSections;
+ std::vector<Detail::AssertionOrBenchmarkResult> assertionsAndBenchmarks;
+ std::string stdOut;
+ std::string stdErr;
+ };
+
+
+ using TestCaseNode = Node<TestCaseStats, SectionNode>;
+ using TestRunNode = Node<TestRunStats, TestCaseNode>;
+
+ // GCC5 compat: we cannot use inherited constructor, because it
+ // doesn't implement backport of P0136
+ CumulativeReporterBase(ReporterConfig&& _config):
+ ReporterBase(CATCH_MOVE(_config))
+ {}
+ ~CumulativeReporterBase() override;
+
+ void benchmarkPreparing( StringRef ) override {}
+ void benchmarkStarting( BenchmarkInfo const& ) override {}
+ void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+ void benchmarkFailed( StringRef ) override {}
+
+ void noMatchingTestCases( StringRef ) override {}
+ void reportInvalidTestSpec( StringRef ) override {}
+ void fatalErrorEncountered( StringRef /*error*/ ) override {}
+
+ void testRunStarting( TestRunInfo const& ) override {}
+
+ void testCaseStarting( TestCaseInfo const& ) override {}
+ void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
+ void sectionStarting( SectionInfo const& sectionInfo ) override;
+
+ void assertionStarting( AssertionInfo const& ) override {}
+
+ void assertionEnded( AssertionStats const& assertionStats ) override;
+ void sectionEnded( SectionStats const& sectionStats ) override;
+ void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
+ void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+ void testRunEnded( TestRunStats const& testRunStats ) override;
+ //! Customization point: called after last test finishes (testRunEnded has been handled)
+ virtual void testRunEndedCumulative() = 0;
+
+ void skipTest(TestCaseInfo const&) override {}
+
+ protected:
+ //! Should the cumulative base store the assertion expansion for successful assertions?
+ bool m_shouldStoreSuccesfulAssertions = true;
+ //! Should the cumulative base store the assertion expansion for failed assertions?
+ bool m_shouldStoreFailedAssertions = true;
+
+ // We need lazy construction here. We should probably refactor it
+ // later, after the events are redone.
+ //! The root node of the test run tree.
+ Detail::unique_ptr<TestRunNode> m_testRun;
+
+ private:
+ // Note: We rely on pointer identity being stable, which is why
+ // we store pointers to the nodes rather than the values.
+ std::vector<Detail::unique_ptr<TestCaseNode>> m_testCases;
+ // Root section of the _current_ test case
+ Detail::unique_ptr<SectionNode> m_rootSection;
+ // Deepest section of the _current_ test case
+ SectionNode* m_deepestSection = nullptr;
+ // Stack of _active_ sections in the _current_ test case
+ std::vector<SectionNode*> m_sectionStack;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+#define CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+
+
+namespace Catch {
+
+ /**
+ * Base class to simplify implementing listeners.
+ *
+ * Provides empty default implementation for all IEventListener member
+ * functions, so that a listener implementation can pick which
+ * member functions it actually cares about.
+ */
+ class EventListenerBase : public IEventListener {
+ public:
+ using IEventListener::IEventListener;
+
+ void reportInvalidTestSpec( StringRef unmatchedSpec ) override;
+ void fatalErrorEncountered( StringRef error ) override;
+
+ void benchmarkPreparing( StringRef name ) override;
+ void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+ void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+ void benchmarkFailed( StringRef error ) override;
+
+ void assertionStarting( AssertionInfo const& assertionInfo ) override;
+ void assertionEnded( AssertionStats const& assertionStats ) override;
+
+ void listReporters(
+ std::vector<ReporterDescription> const& descriptions ) override;
+ void listListeners(
+ std::vector<ListenerDescription> const& descriptions ) override;
+ void listTests( std::vector<TestCaseHandle> const& tests ) override;
+ void listTags( std::vector<TagInfo> const& tagInfos ) override;
+
+ void noMatchingTestCases( StringRef unmatchedSpec ) override;
+ void testRunStarting( TestRunInfo const& testRunInfo ) override;
+ void testCaseStarting( TestCaseInfo const& testInfo ) override;
+ void testCasePartialStarting( TestCaseInfo const& testInfo,
+ uint64_t partNumber ) override;
+ void sectionStarting( SectionInfo const& sectionInfo ) override;
+ void sectionEnded( SectionStats const& sectionStats ) override;
+ void testCasePartialEnded( TestCaseStats const& testCaseStats,
+ uint64_t partNumber ) override;
+ void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+ void testRunEnded( TestRunStats const& testRunStats ) override;
+ void skipTest( TestCaseInfo const& testInfo ) override;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_HELPERS_HPP_INCLUDED
+#define CATCH_REPORTER_HELPERS_HPP_INCLUDED
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+
+
+namespace Catch {
+
+ class IConfig;
+ class TestCaseHandle;
+ class ColourImpl;
+
+ // Returns double formatted as %.3f (format expected on output)
+ std::string getFormattedDuration( double duration );
+
+ //! Should the reporter show duration of test given current configuration?
+ bool shouldShowDuration( IConfig const& config, double duration );
+
+ std::string serializeFilters( std::vector<std::string> const& filters );
+
+ struct lineOfChars {
+ char c;
+ constexpr lineOfChars( char c_ ): c( c_ ) {}
+
+ friend std::ostream& operator<<( std::ostream& out, lineOfChars value );
+ };
+
+ /**
+ * Lists reporter descriptions to the provided stream in user-friendly
+ * format
+ *
+ * Used as the default listing implementation by the first party reporter
+ * bases. The output should be backwards compatible with the output of
+ * Catch2 v2 binaries.
+ */
+ void
+ defaultListReporters( std::ostream& out,
+ std::vector<ReporterDescription> const& descriptions,
+ Verbosity verbosity );
+
+ /**
+ * Lists listeners descriptions to the provided stream in user-friendly
+ * format
+ */
+ void defaultListListeners( std::ostream& out,
+ std::vector<ListenerDescription> const& descriptions );
+
+ /**
+ * Lists tag information to the provided stream in user-friendly format
+ *
+ * Used as the default listing implementation by the first party reporter
+ * bases. The output should be backwards compatible with the output of
+ * Catch2 v2 binaries.
+ */
+ void defaultListTags( std::ostream& out, std::vector<TagInfo> const& tags, bool isFiltered );
+
+ /**
+ * Lists test case information to the provided stream in user-friendly
+ * format
+ *
+ * Used as the default listing implementation by the first party reporter
+ * bases. The output is backwards compatible with the output of Catch2
+ * v2 binaries, and also supports the format specific to the old
+ * `--list-test-names-only` option, for people who used it in integrations.
+ */
+ void defaultListTests( std::ostream& out,
+ ColourImpl* streamColour,
+ std::vector<TestCaseHandle> const& tests,
+ bool isFiltered,
+ Verbosity verbosity );
+
+ /**
+ * Prints test run totals to the provided stream in user-friendly format
+ *
+ * Used by the console and compact reporters.
+ */
+ void printTestRunTotals( std::ostream& stream,
+ ColourImpl& streamColour,
+ Totals const& totals );
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_HELPERS_HPP_INCLUDED
+
+
+
+#ifndef CATCH_REPORTER_JSON_HPP_INCLUDED
+#define CATCH_REPORTER_JSON_HPP_INCLUDED
+
+
+#include <stack>
+
+namespace Catch {
+ class JsonReporter : public StreamingReporterBase {
+ public:
+ JsonReporter( ReporterConfig&& config );
+
+ ~JsonReporter() override;
+
+ static std::string getDescription();
+
+ public: // StreamingReporterBase
+ void testRunStarting( TestRunInfo const& runInfo ) override;
+ void testRunEnded( TestRunStats const& runStats ) override;
+
+ void testCaseStarting( TestCaseInfo const& tcInfo ) override;
+ void testCaseEnded( TestCaseStats const& tcStats ) override;
+
+ void testCasePartialStarting( TestCaseInfo const& tcInfo,
+ uint64_t index ) override;
+ void testCasePartialEnded( TestCaseStats const& tcStats,
+ uint64_t index ) override;
+
+ void sectionStarting( SectionInfo const& sectionInfo ) override;
+ void sectionEnded( SectionStats const& sectionStats ) override;
+
+ void assertionStarting( AssertionInfo const& assertionInfo ) override;
+ void assertionEnded( AssertionStats const& assertionStats ) override;
+
+ //void testRunEndedCumulative() override;
+
+ void benchmarkPreparing( StringRef name ) override;
+ void benchmarkStarting( BenchmarkInfo const& ) override;
+ void benchmarkEnded( BenchmarkStats<> const& ) override;
+ void benchmarkFailed( StringRef error ) override;
+
+ void listReporters(
+ std::vector<ReporterDescription> const& descriptions ) override;
+ void listListeners(
+ std::vector<ListenerDescription> const& descriptions ) override;
+ void listTests( std::vector<TestCaseHandle> const& tests ) override;
+ void listTags( std::vector<TagInfo> const& tags ) override;
+
+ private:
+ Timer m_testCaseTimer;
+ enum class Writer {
+ Object,
+ Array
+ };
+
+ JsonArrayWriter& startArray();
+ JsonArrayWriter& startArray( StringRef key );
+
+ JsonObjectWriter& startObject();
+ JsonObjectWriter& startObject( StringRef key );
+
+ void endObject();
+ void endArray();
+
+ bool isInside( Writer writer );
+
+ void startListing();
+ void endListing();
+
+ // Invariant:
+ // When m_writers is not empty and its top element is
+ // - Writer::Object, then m_objectWriters is not be empty
+ // - Writer::Array, then m_arrayWriters shall not be empty
+ std::stack<JsonObjectWriter> m_objectWriters{};
+ std::stack<JsonArrayWriter> m_arrayWriters{};
+ std::stack<Writer> m_writers{};
+
+ bool m_startedListing = false;
+
+ // std::size_t m_sectionDepth = 0;
+ // std::size_t m_sectionStarted = 0;
+ };
+} // namespace Catch
+
+#endif // CATCH_REPORTER_JSON_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_JUNIT_HPP_INCLUDED
+#define CATCH_REPORTER_JUNIT_HPP_INCLUDED
+
+
+
+namespace Catch {
+
+ class JunitReporter final : public CumulativeReporterBase {
+ public:
+ JunitReporter(ReporterConfig&& _config);
+
+ static std::string getDescription();
+
+ void testRunStarting(TestRunInfo const& runInfo) override;
+
+ void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+ void assertionEnded(AssertionStats const& assertionStats) override;
+
+ void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+ void testRunEndedCumulative() override;
+
+ private:
+ void writeRun(TestRunNode const& testRunNode, double suiteTime);
+
+ void writeTestCase(TestCaseNode const& testCaseNode);
+
+ void writeSection( std::string const& className,
+ std::string const& rootName,
+ SectionNode const& sectionNode,
+ bool testOkToFail );
+
+ void writeAssertions(SectionNode const& sectionNode);
+ void writeAssertion(AssertionStats const& stats);
+
+ XmlWriter xml;
+ Timer suiteTimer;
+ std::string stdOutForSuite;
+ std::string stdErrForSuite;
+ unsigned int unexpectedExceptions = 0;
+ bool m_okToFail = false;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_JUNIT_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_MULTI_HPP_INCLUDED
+#define CATCH_REPORTER_MULTI_HPP_INCLUDED
+
+
+namespace Catch {
+
+ class MultiReporter final : public IEventListener {
+ /*
+ * Stores all added reporters and listeners
+ *
+ * All Listeners are stored before all reporters, and individual
+ * listeners/reporters are stored in order of insertion.
+ */
+ std::vector<IEventListenerPtr> m_reporterLikes;
+ bool m_haveNoncapturingReporters = false;
+
+ // Keep track of how many listeners we have already inserted,
+ // so that we can insert them into the main vector at the right place
+ size_t m_insertedListeners = 0;
+
+ void updatePreferences(IEventListener const& reporterish);
+
+ public:
+ using IEventListener::IEventListener;
+
+ void addListener( IEventListenerPtr&& listener );
+ void addReporter( IEventListenerPtr&& reporter );
+
+ public: // IEventListener
+
+ void noMatchingTestCases( StringRef unmatchedSpec ) override;
+ void fatalErrorEncountered( StringRef error ) override;
+ void reportInvalidTestSpec( StringRef arg ) override;
+
+ void benchmarkPreparing( StringRef name ) override;
+ void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+ void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+ void benchmarkFailed( StringRef error ) override;
+
+ void testRunStarting( TestRunInfo const& testRunInfo ) override;
+ void testCaseStarting( TestCaseInfo const& testInfo ) override;
+ void testCasePartialStarting(TestCaseInfo const& testInfo, uint64_t partNumber) override;
+ void sectionStarting( SectionInfo const& sectionInfo ) override;
+ void assertionStarting( AssertionInfo const& assertionInfo ) override;
+
+ void assertionEnded( AssertionStats const& assertionStats ) override;
+ void sectionEnded( SectionStats const& sectionStats ) override;
+ void testCasePartialEnded(TestCaseStats const& testStats, uint64_t partNumber) override;
+ void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+ void testRunEnded( TestRunStats const& testRunStats ) override;
+
+ void skipTest( TestCaseInfo const& testInfo ) override;
+
+ void listReporters(std::vector<ReporterDescription> const& descriptions) override;
+ void listListeners(std::vector<ListenerDescription> const& descriptions) override;
+ void listTests(std::vector<TestCaseHandle> const& tests) override;
+ void listTags(std::vector<TagInfo> const& tags) override;
+
+
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_MULTI_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+#define CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+
+
+#include <type_traits>
+
+namespace Catch {
+
+ namespace Detail {
+
+ template <typename T, typename = void>
+ struct has_description : std::false_type {};
+
+ template <typename T>
+ struct has_description<
+ T,
+ void_t<decltype( T::getDescription() )>>
+ : std::true_type {};
+
+ //! Indirection for reporter registration, so that the error handling is
+ //! independent on the reporter's concrete type
+ void registerReporterImpl( std::string const& name,
+ IReporterFactoryPtr reporterPtr );
+ //! Actually registers the factory, independent on listener's concrete type
+ void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory );
+ } // namespace Detail
+
+ class IEventListener;
+ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+
+ template <typename T>
+ class ReporterFactory : public IReporterFactory {
+
+ IEventListenerPtr create( ReporterConfig&& config ) const override {
+ return Detail::make_unique<T>( CATCH_MOVE(config) );
+ }
+
+ std::string getDescription() const override {
+ return T::getDescription();
+ }
+ };
+
+
+ template<typename T>
+ class ReporterRegistrar {
+ public:
+ explicit ReporterRegistrar( std::string const& name ) {
+ registerReporterImpl( name,
+ Detail::make_unique<ReporterFactory<T>>() );
+ }
+ };
+
+ template<typename T>
+ class ListenerRegistrar {
+
+ class TypedListenerFactory : public EventListenerFactory {
+ StringRef m_listenerName;
+
+ std::string getDescriptionImpl( std::true_type ) const {
+ return T::getDescription();
+ }
+
+ std::string getDescriptionImpl( std::false_type ) const {
+ return "(No description provided)";
+ }
+
+ public:
+ TypedListenerFactory( StringRef listenerName ):
+ m_listenerName( listenerName ) {}
+
+ IEventListenerPtr create( IConfig const* config ) const override {
+ return Detail::make_unique<T>( config );
+ }
+
+ StringRef getName() const override {
+ return m_listenerName;
+ }
+
+ std::string getDescription() const override {
+ return getDescriptionImpl( Detail::has_description<T>{} );
+ }
+ };
+
+ public:
+ ListenerRegistrar(StringRef listenerName) {
+ registerListenerImpl( Detail::make_unique<TypedListenerFactory>(listenerName) );
+ }
+ };
+}
+
+#if !defined(CATCH_CONFIG_DISABLE)
+
+# define CATCH_REGISTER_REPORTER( name, reporterType ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ namespace { \
+ Catch::ReporterRegistrar<reporterType> INTERNAL_CATCH_UNIQUE_NAME( \
+ catch_internal_RegistrarFor )( name ); \
+ } \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+# define CATCH_REGISTER_LISTENER( listenerType ) \
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+ namespace { \
+ Catch::ListenerRegistrar<listenerType> INTERNAL_CATCH_UNIQUE_NAME( \
+ catch_internal_RegistrarFor )( #listenerType##_catch_sr ); \
+ } \
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+#else // CATCH_CONFIG_DISABLE
+
+#define CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LISTENER(listenerType)
+
+#endif // CATCH_CONFIG_DISABLE
+
+#endif // CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+
+namespace Catch {
+
+ class SonarQubeReporter final : public CumulativeReporterBase {
+ public:
+ SonarQubeReporter(ReporterConfig&& config)
+ : CumulativeReporterBase(CATCH_MOVE(config))
+ , xml(m_stream) {
+ m_preferences.shouldRedirectStdOut = true;
+ m_preferences.shouldReportAllAssertions = true;
+ m_shouldStoreSuccesfulAssertions = false;
+ }
+
+ static std::string getDescription() {
+ using namespace std::string_literals;
+ return "Reports test results in the Generic Test Data SonarQube XML format"s;
+ }
+
+ void testRunStarting( TestRunInfo const& testRunInfo ) override;
+
+ void testRunEndedCumulative() override {
+ writeRun( *m_testRun );
+ xml.endElement();
+ }
+
+ void writeRun( TestRunNode const& runNode );
+
+ void writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes);
+
+ void writeTestCase(TestCaseNode const& testCaseNode);
+
+ void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail);
+
+ void writeAssertions(SectionNode const& sectionNode, bool okToFail);
+
+ void writeAssertion(AssertionStats const& stats, bool okToFail);
+
+ private:
+ XmlWriter xml;
+ };
+
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_TAP_HPP_INCLUDED
+#define CATCH_REPORTER_TAP_HPP_INCLUDED
+
+
+namespace Catch {
+
+ class TAPReporter final : public StreamingReporterBase {
+ public:
+ TAPReporter( ReporterConfig&& config ):
+ StreamingReporterBase( CATCH_MOVE(config) ) {
+ m_preferences.shouldReportAllAssertions = true;
+ }
+
+ static std::string getDescription() {
+ using namespace std::string_literals;
+ return "Reports test results in TAP format, suitable for test harnesses"s;
+ }
+
+ void testRunStarting( TestRunInfo const& testInfo ) override;
+
+ void noMatchingTestCases( StringRef unmatchedSpec ) override;
+
+ void assertionEnded(AssertionStats const& _assertionStats) override;
+
+ void testRunEnded(TestRunStats const& _testRunStats) override;
+
+ private:
+ std::size_t counter = 0;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_TAP_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+#define CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+
+#include <cstring>
+
+#ifdef __clang__
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+ class TeamCityReporter final : public StreamingReporterBase {
+ public:
+ TeamCityReporter( ReporterConfig&& _config )
+ : StreamingReporterBase( CATCH_MOVE(_config) )
+ {
+ m_preferences.shouldRedirectStdOut = true;
+ }
+
+ ~TeamCityReporter() override;
+
+ static std::string getDescription() {
+ using namespace std::string_literals;
+ return "Reports test results as TeamCity service messages"s;
+ }
+
+ void testRunStarting( TestRunInfo const& runInfo ) override;
+ void testRunEnded( TestRunStats const& runStats ) override;
+
+
+ void assertionEnded(AssertionStats const& assertionStats) override;
+
+ void sectionStarting(SectionInfo const& sectionInfo) override {
+ m_headerPrintedForThisSection = false;
+ StreamingReporterBase::sectionStarting( sectionInfo );
+ }
+
+ void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+ void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+ private:
+ void printSectionHeader(std::ostream& os);
+
+ bool m_headerPrintedForThisSection = false;
+ Timer m_testTimer;
+ };
+
+} // end namespace Catch
+
+#ifdef __clang__
+# pragma clang diagnostic pop
+#endif
+
+#endif // CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+
+
+#ifndef CATCH_REPORTER_XML_HPP_INCLUDED
+#define CATCH_REPORTER_XML_HPP_INCLUDED
+
+
+
+
+namespace Catch {
+ class XmlReporter : public StreamingReporterBase {
+ public:
+ XmlReporter(ReporterConfig&& _config);
+
+ ~XmlReporter() override;
+
+ static std::string getDescription();
+
+ virtual std::string getStylesheetRef() const;
+
+ void writeSourceInfo(SourceLineInfo const& sourceInfo);
+
+ public: // StreamingReporterBase
+
+ void testRunStarting(TestRunInfo const& testInfo) override;
+
+ void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+ void sectionStarting(SectionInfo const& sectionInfo) override;
+
+ void assertionStarting(AssertionInfo const&) override;
+
+ void assertionEnded(AssertionStats const& assertionStats) override;
+
+ void sectionEnded(SectionStats const& sectionStats) override;
+
+ void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+ void testRunEnded(TestRunStats const& testRunStats) override;
+
+ void benchmarkPreparing( StringRef name ) override;
+ void benchmarkStarting(BenchmarkInfo const&) override;
+ void benchmarkEnded(BenchmarkStats<> const&) override;
+ void benchmarkFailed( StringRef error ) override;
+
+ void listReporters(std::vector<ReporterDescription> const& descriptions) override;
+ void listListeners(std::vector<ListenerDescription> const& descriptions) override;
+ void listTests(std::vector<TestCaseHandle> const& tests) override;
+ void listTags(std::vector<TagInfo> const& tags) override;
+
+ private:
+ Timer m_testCaseTimer;
+ XmlWriter m_xml;
+ int m_sectionDepth = 0;
+ };
+
+} // end namespace Catch
+
+#endif // CATCH_REPORTER_XML_HPP_INCLUDED
+
+#endif // CATCH_REPORTERS_ALL_HPP_INCLUDED
+
+#endif // CATCH_ALL_HPP_INCLUDED
+#endif // CATCH_AMALGAMATED_HPP_INCLUDED
--- /dev/null
+
+// Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE.txt or copy at
+// https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+// Catch v3.6.0
+// Generated: 2024-05-05 20:53:27.562886
+// ----------------------------------------------------------
+// This file is an amalgamation of multiple different files.
+// You probably shouldn't edit it directly.
+// ----------------------------------------------------------
+
+#include "catch.hpp"
+
+
+#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+
+
+#if defined(CATCH_PLATFORM_WINDOWS)
+
+// We might end up with the define made globally through the compiler,
+// and we don't want to trigger warnings for this
+#if !defined(NOMINMAX)
+# define NOMINMAX
+#endif
+#if !defined(WIN32_LEAN_AND_MEAN)
+# define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <windows.h>
+
+#endif // defined(CATCH_PLATFORM_WINDOWS)
+
+#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+
+
+
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ ChronometerConcept::~ChronometerConcept() = default;
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+
+// Adapted from donated nonius code.
+
+
+#include <vector>
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last) {
+ if (!cfg.benchmarkNoAnalysis()) {
+ std::vector<double> samples;
+ samples.reserve(static_cast<size_t>(last - first));
+ for (auto current = first; current != last; ++current) {
+ samples.push_back( current->count() );
+ }
+
+ auto analysis = Catch::Benchmark::Detail::analyse_samples(
+ cfg.benchmarkConfidenceInterval(),
+ cfg.benchmarkResamples(),
+ samples.data(),
+ samples.data() + samples.size() );
+ auto outliers = Catch::Benchmark::Detail::classify_outliers(
+ samples.data(), samples.data() + samples.size() );
+
+ auto wrap_estimate = [](Estimate<double> e) {
+ return Estimate<FDuration> {
+ FDuration(e.point),
+ FDuration(e.lower_bound),
+ FDuration(e.upper_bound),
+ e.confidence_interval,
+ };
+ };
+ std::vector<FDuration> samples2;
+ samples2.reserve(samples.size());
+ for (auto s : samples) {
+ samples2.push_back( FDuration( s ) );
+ }
+
+ return {
+ CATCH_MOVE(samples2),
+ wrap_estimate(analysis.mean),
+ wrap_estimate(analysis.standard_deviation),
+ outliers,
+ analysis.outlier_variance,
+ };
+ } else {
+ std::vector<FDuration> samples;
+ samples.reserve(static_cast<size_t>(last - first));
+
+ FDuration mean = FDuration(0);
+ int i = 0;
+ for (auto it = first; it < last; ++it, ++i) {
+ samples.push_back(*it);
+ mean += *it;
+ }
+ mean /= i;
+
+ return SampleAnalysis{
+ CATCH_MOVE(samples),
+ Estimate<FDuration>{ mean, mean, mean, 0.0 },
+ Estimate<FDuration>{ FDuration( 0 ),
+ FDuration( 0 ),
+ FDuration( 0 ),
+ 0.0 },
+ OutlierClassification{},
+ 0.0
+ };
+ }
+ }
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+
+
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ BenchmarkFunction::callable::~callable() = default;
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+
+
+
+#include <exception>
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ struct optimized_away_error : std::exception {
+ const char* what() const noexcept override;
+ };
+
+ const char* optimized_away_error::what() const noexcept {
+ return "could not measure benchmark, maybe it was optimized away";
+ }
+
+ void throw_optimized_away_error() {
+ Catch::throw_exception(optimized_away_error{});
+ }
+
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+
+// Adapted from donated nonius code.
+
+
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstddef>
+#include <numeric>
+#include <random>
+
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <future>
+#endif
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+ namespace {
+
+ template <typename URng, typename Estimator>
+ static sample
+ resample( URng& rng,
+ unsigned int resamples,
+ double const* first,
+ double const* last,
+ Estimator& estimator ) {
+ auto n = static_cast<size_t>( last - first );
+ Catch::uniform_integer_distribution<size_t> dist( 0, n - 1 );
+
+ sample out;
+ out.reserve( resamples );
+ std::vector<double> resampled;
+ resampled.reserve( n );
+ for ( size_t i = 0; i < resamples; ++i ) {
+ resampled.clear();
+ for ( size_t s = 0; s < n; ++s ) {
+ resampled.push_back( first[dist( rng )] );
+ }
+ const auto estimate =
+ estimator( resampled.data(), resampled.data() + resampled.size() );
+ out.push_back( estimate );
+ }
+ std::sort( out.begin(), out.end() );
+ return out;
+ }
+
+ static double outlier_variance( Estimate<double> mean,
+ Estimate<double> stddev,
+ int n ) {
+ double sb = stddev.point;
+ double mn = mean.point / n;
+ double mg_min = mn / 2.;
+ double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) );
+ double sg2 = sg * sg;
+ double sb2 = sb * sb;
+
+ auto c_max = [n, mn, sb2, sg2]( double x ) -> double {
+ double k = mn - x;
+ double d = k * k;
+ double nd = n * d;
+ double k0 = -n * nd;
+ double k1 = sb2 - n * sg2 + nd;
+ double det = k1 * k1 - 4 * sg2 * k0;
+ return static_cast<int>( -2. * k0 /
+ ( k1 + std::sqrt( det ) ) );
+ };
+
+ auto var_out = [n, sb2, sg2]( double c ) {
+ double nc = n - c;
+ return ( nc / n ) * ( sb2 - nc * sg2 );
+ };
+
+ return (std::min)( var_out( 1 ),
+ var_out(
+ (std::min)( c_max( 0. ),
+ c_max( mg_min ) ) ) ) /
+ sb2;
+ }
+
+ static double erf_inv( double x ) {
+ // Code accompanying the article "Approximating the erfinv
+ // function" in GPU Computing Gems, Volume 2
+ double w, p;
+
+ w = -log( ( 1.0 - x ) * ( 1.0 + x ) );
+
+ if ( w < 6.250000 ) {
+ w = w - 3.125000;
+ p = -3.6444120640178196996e-21;
+ p = -1.685059138182016589e-19 + p * w;
+ p = 1.2858480715256400167e-18 + p * w;
+ p = 1.115787767802518096e-17 + p * w;
+ p = -1.333171662854620906e-16 + p * w;
+ p = 2.0972767875968561637e-17 + p * w;
+ p = 6.6376381343583238325e-15 + p * w;
+ p = -4.0545662729752068639e-14 + p * w;
+ p = -8.1519341976054721522e-14 + p * w;
+ p = 2.6335093153082322977e-12 + p * w;
+ p = -1.2975133253453532498e-11 + p * w;
+ p = -5.4154120542946279317e-11 + p * w;
+ p = 1.051212273321532285e-09 + p * w;
+ p = -4.1126339803469836976e-09 + p * w;
+ p = -2.9070369957882005086e-08 + p * w;
+ p = 4.2347877827932403518e-07 + p * w;
+ p = -1.3654692000834678645e-06 + p * w;
+ p = -1.3882523362786468719e-05 + p * w;
+ p = 0.0001867342080340571352 + p * w;
+ p = -0.00074070253416626697512 + p * w;
+ p = -0.0060336708714301490533 + p * w;
+ p = 0.24015818242558961693 + p * w;
+ p = 1.6536545626831027356 + p * w;
+ } else if ( w < 16.000000 ) {
+ w = sqrt( w ) - 3.250000;
+ p = 2.2137376921775787049e-09;
+ p = 9.0756561938885390979e-08 + p * w;
+ p = -2.7517406297064545428e-07 + p * w;
+ p = 1.8239629214389227755e-08 + p * w;
+ p = 1.5027403968909827627e-06 + p * w;
+ p = -4.013867526981545969e-06 + p * w;
+ p = 2.9234449089955446044e-06 + p * w;
+ p = 1.2475304481671778723e-05 + p * w;
+ p = -4.7318229009055733981e-05 + p * w;
+ p = 6.8284851459573175448e-05 + p * w;
+ p = 2.4031110387097893999e-05 + p * w;
+ p = -0.0003550375203628474796 + p * w;
+ p = 0.00095328937973738049703 + p * w;
+ p = -0.0016882755560235047313 + p * w;
+ p = 0.0024914420961078508066 + p * w;
+ p = -0.0037512085075692412107 + p * w;
+ p = 0.005370914553590063617 + p * w;
+ p = 1.0052589676941592334 + p * w;
+ p = 3.0838856104922207635 + p * w;
+ } else {
+ w = sqrt( w ) - 5.000000;
+ p = -2.7109920616438573243e-11;
+ p = -2.5556418169965252055e-10 + p * w;
+ p = 1.5076572693500548083e-09 + p * w;
+ p = -3.7894654401267369937e-09 + p * w;
+ p = 7.6157012080783393804e-09 + p * w;
+ p = -1.4960026627149240478e-08 + p * w;
+ p = 2.9147953450901080826e-08 + p * w;
+ p = -6.7711997758452339498e-08 + p * w;
+ p = 2.2900482228026654717e-07 + p * w;
+ p = -9.9298272942317002539e-07 + p * w;
+ p = 4.5260625972231537039e-06 + p * w;
+ p = -1.9681778105531670567e-05 + p * w;
+ p = 7.5995277030017761139e-05 + p * w;
+ p = -0.00021503011930044477347 + p * w;
+ p = -0.00013871931833623122026 + p * w;
+ p = 1.0103004648645343977 + p * w;
+ p = 4.8499064014085844221 + p * w;
+ }
+ return p * x;
+ }
+
+ static double
+ standard_deviation( double const* first, double const* last ) {
+ auto m = Catch::Benchmark::Detail::mean( first, last );
+ double variance =
+ std::accumulate( first,
+ last,
+ 0.,
+ [m]( double a, double b ) {
+ double diff = b - m;
+ return a + diff * diff;
+ } ) /
+ ( last - first );
+ return std::sqrt( variance );
+ }
+
+ static sample jackknife( double ( *estimator )( double const*,
+ double const* ),
+ double* first,
+ double* last ) {
+ const auto second = first + 1;
+ sample results;
+ results.reserve( static_cast<size_t>( last - first ) );
+
+ for ( auto it = first; it != last; ++it ) {
+ std::iter_swap( it, first );
+ results.push_back( estimator( second, last ) );
+ }
+
+ return results;
+ }
+
+
+ } // namespace
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+namespace Catch {
+ namespace Benchmark {
+ namespace Detail {
+
+ double weighted_average_quantile( int k,
+ int q,
+ double* first,
+ double* last ) {
+ auto count = last - first;
+ double idx = (count - 1) * k / static_cast<double>(q);
+ int j = static_cast<int>(idx);
+ double g = idx - j;
+ std::nth_element(first, first + j, last);
+ auto xj = first[j];
+ if ( Catch::Detail::directCompare( g, 0 ) ) {
+ return xj;
+ }
+
+ auto xj1 = *std::min_element(first + (j + 1), last);
+ return xj + g * (xj1 - xj);
+ }
+
+ OutlierClassification
+ classify_outliers( double const* first, double const* last ) {
+ std::vector<double> copy( first, last );
+
+ auto q1 = weighted_average_quantile( 1, 4, copy.data(), copy.data() + copy.size() );
+ auto q3 = weighted_average_quantile( 3, 4, copy.data(), copy.data() + copy.size() );
+ auto iqr = q3 - q1;
+ auto los = q1 - ( iqr * 3. );
+ auto lom = q1 - ( iqr * 1.5 );
+ auto him = q3 + ( iqr * 1.5 );
+ auto his = q3 + ( iqr * 3. );
+
+ OutlierClassification o;
+ for ( ; first != last; ++first ) {
+ const double t = *first;
+ if ( t < los ) {
+ ++o.low_severe;
+ } else if ( t < lom ) {
+ ++o.low_mild;
+ } else if ( t > his ) {
+ ++o.high_severe;
+ } else if ( t > him ) {
+ ++o.high_mild;
+ }
+ ++o.samples_seen;
+ }
+ return o;
+ }
+
+ double mean( double const* first, double const* last ) {
+ auto count = last - first;
+ double sum = 0.;
+ while (first != last) {
+ sum += *first;
+ ++first;
+ }
+ return sum / static_cast<double>(count);
+ }
+
+ double normal_cdf( double x ) {
+ return std::erfc( -x / std::sqrt( 2.0 ) ) / 2.0;
+ }
+
+ double erfc_inv(double x) {
+ return erf_inv(1.0 - x);
+ }
+
+ double normal_quantile(double p) {
+ static const double ROOT_TWO = std::sqrt(2.0);
+
+ double result = 0.0;
+ assert(p >= 0 && p <= 1);
+ if (p < 0 || p > 1) {
+ return result;
+ }
+
+ result = -erfc_inv(2.0 * p);
+ // result *= normal distribution standard deviation (1.0) * sqrt(2)
+ result *= /*sd * */ ROOT_TWO;
+ // result += normal disttribution mean (0)
+ return result;
+ }
+
+ Estimate<double>
+ bootstrap( double confidence_level,
+ double* first,
+ double* last,
+ sample const& resample,
+ double ( *estimator )( double const*, double const* ) ) {
+ auto n_samples = last - first;
+
+ double point = estimator( first, last );
+ // Degenerate case with a single sample
+ if ( n_samples == 1 )
+ return { point, point, point, confidence_level };
+
+ sample jack = jackknife( estimator, first, last );
+ double jack_mean =
+ mean( jack.data(), jack.data() + jack.size() );
+ double sum_squares = 0, sum_cubes = 0;
+ for ( double x : jack ) {
+ auto difference = jack_mean - x;
+ auto square = difference * difference;
+ auto cube = square * difference;
+ sum_squares += square;
+ sum_cubes += cube;
+ }
+
+ double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) );
+ long n = static_cast<long>( resample.size() );
+ double prob_n =
+ std::count_if( resample.begin(),
+ resample.end(),
+ [point]( double x ) { return x < point; } ) /
+ static_cast<double>( n );
+ // degenerate case with uniform samples
+ if ( Catch::Detail::directCompare( prob_n, 0. ) ) {
+ return { point, point, point, confidence_level };
+ }
+
+ double bias = normal_quantile( prob_n );
+ double z1 = normal_quantile( ( 1. - confidence_level ) / 2. );
+
+ auto cumn = [n]( double x ) -> long {
+ return std::lround( normal_cdf( x ) *
+ static_cast<double>( n ) );
+ };
+ auto a = [bias, accel]( double b ) {
+ return bias + b / ( 1. - accel * b );
+ };
+ double b1 = bias + z1;
+ double b2 = bias - z1;
+ double a1 = a( b1 );
+ double a2 = a( b2 );
+ auto lo = static_cast<size_t>( (std::max)( cumn( a1 ), 0l ) );
+ auto hi =
+ static_cast<size_t>( (std::min)( cumn( a2 ), n - 1 ) );
+
+ return { point, resample[lo], resample[hi], confidence_level };
+ }
+
+ bootstrap_analysis analyse_samples(double confidence_level,
+ unsigned int n_resamples,
+ double* first,
+ double* last) {
+ auto mean = &Detail::mean;
+ auto stddev = &standard_deviation;
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+ auto Estimate = [=](double(*f)(double const*, double const*)) {
+ std::random_device rd;
+ auto seed = rd();
+ return std::async(std::launch::async, [=] {
+ SimplePcg32 rng( seed );
+ auto resampled = resample(rng, n_resamples, first, last, f);
+ return bootstrap(confidence_level, first, last, resampled, f);
+ });
+ };
+
+ auto mean_future = Estimate(mean);
+ auto stddev_future = Estimate(stddev);
+
+ auto mean_estimate = mean_future.get();
+ auto stddev_estimate = stddev_future.get();
+#else
+ auto Estimate = [=](double(*f)(double const* , double const*)) {
+ std::random_device rd;
+ auto seed = rd();
+ SimplePcg32 rng( seed );
+ auto resampled = resample(rng, n_resamples, first, last, f);
+ return bootstrap(confidence_level, first, last, resampled, f);
+ };
+
+ auto mean_estimate = Estimate(mean);
+ auto stddev_estimate = Estimate(stddev);
+#endif // CATCH_USE_ASYNC
+
+ auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+ double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+
+ return { mean_estimate, stddev_estimate, outlier_variance };
+ }
+ } // namespace Detail
+ } // namespace Benchmark
+} // namespace Catch
+
+
+
+#include <cmath>
+#include <limits>
+
+namespace {
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+ return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+}
+
+namespace Catch {
+
+ Approx::Approx ( double value )
+ : m_epsilon( static_cast<double>(std::numeric_limits<float>::epsilon())*100. ),
+ m_margin( 0.0 ),
+ m_scale( 0.0 ),
+ m_value( value )
+ {}
+
+ Approx Approx::custom() {
+ return Approx( 0 );
+ }
+
+ Approx Approx::operator-() const {
+ auto temp(*this);
+ temp.m_value = -temp.m_value;
+ return temp;
+ }
+
+
+ std::string Approx::toString() const {
+ ReusableStringStream rss;
+ rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
+ return rss.str();
+ }
+
+ bool Approx::equalityComparisonImpl(const double other) const {
+ // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
+ // Thanks to Richard Harris for his help refining the scaled margin value
+ return marginComparison(m_value, other, m_margin)
+ || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+ }
+
+ void Approx::setMargin(double newMargin) {
+ CATCH_ENFORCE(newMargin >= 0,
+ "Invalid Approx::margin: " << newMargin << '.'
+ << " Approx::Margin has to be non-negative.");
+ m_margin = newMargin;
+ }
+
+ void Approx::setEpsilon(double newEpsilon) {
+ CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+ "Invalid Approx::epsilon: " << newEpsilon << '.'
+ << " Approx::epsilon has to be in [0, 1]");
+ m_epsilon = newEpsilon;
+ }
+
+namespace literals {
+ Approx operator ""_a(long double val) {
+ return Approx(val);
+ }
+ Approx operator ""_a(unsigned long long val) {
+ return Approx(val);
+ }
+} // end namespace literals
+
+std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {
+ return value.toString();
+}
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+ AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+ lazyExpression(_lazyExpression),
+ resultType(_resultType) {}
+
+ std::string AssertionResultData::reconstructExpression() const {
+
+ if( reconstructedExpression.empty() ) {
+ if( lazyExpression ) {
+ ReusableStringStream rss;
+ rss << lazyExpression;
+ reconstructedExpression = rss.str();
+ }
+ }
+ return reconstructedExpression;
+ }
+
+ AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data )
+ : m_info( info ),
+ m_resultData( CATCH_MOVE(data) )
+ {}
+
+ // Result was a success
+ bool AssertionResult::succeeded() const {
+ return Catch::isOk( m_resultData.resultType );
+ }
+
+ // Result was a success, or failure is suppressed
+ bool AssertionResult::isOk() const {
+ return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+ }
+
+ ResultWas::OfType AssertionResult::getResultType() const {
+ return m_resultData.resultType;
+ }
+
+ bool AssertionResult::hasExpression() const {
+ return !m_info.capturedExpression.empty();
+ }
+
+ bool AssertionResult::hasMessage() const {
+ return !m_resultData.message.empty();
+ }
+
+ std::string AssertionResult::getExpression() const {
+ // Possibly overallocating by 3 characters should be basically free
+ std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
+ if (isFalseTest(m_info.resultDisposition)) {
+ expr += "!(";
+ }
+ expr += m_info.capturedExpression;
+ if (isFalseTest(m_info.resultDisposition)) {
+ expr += ')';
+ }
+ return expr;
+ }
+
+ std::string AssertionResult::getExpressionInMacro() const {
+ if ( m_info.macroName.empty() ) {
+ return static_cast<std::string>( m_info.capturedExpression );
+ }
+ std::string expr;
+ expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+ expr += m_info.macroName;
+ expr += "( ";
+ expr += m_info.capturedExpression;
+ expr += " )";
+ return expr;
+ }
+
+ bool AssertionResult::hasExpandedExpression() const {
+ return hasExpression() && getExpandedExpression() != getExpression();
+ }
+
+ std::string AssertionResult::getExpandedExpression() const {
+ std::string expr = m_resultData.reconstructExpression();
+ return expr.empty()
+ ? getExpression()
+ : expr;
+ }
+
+ StringRef AssertionResult::getMessage() const {
+ return m_resultData.message;
+ }
+ SourceLineInfo AssertionResult::getSourceInfo() const {
+ return m_info.lineInfo;
+ }
+
+ StringRef AssertionResult::getTestMacroName() const {
+ return m_info.macroName;
+ }
+
+} // end namespace Catch
+
+
+
+#include <fstream>
+
+namespace Catch {
+
+ namespace {
+ static bool enableBazelEnvSupport() {
+#if defined( CATCH_CONFIG_BAZEL_SUPPORT )
+ return true;
+#else
+ return Detail::getEnv( "BAZEL_TEST" ) != nullptr;
+#endif
+ }
+
+ struct bazelShardingOptions {
+ unsigned int shardIndex, shardCount;
+ std::string shardFilePath;
+ };
+
+ static Optional<bazelShardingOptions> readBazelShardingOptions() {
+ const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" );
+ const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" );
+ const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );
+
+
+ const bool has_all =
+ bazelShardIndex && bazelShardTotal && bazelShardInfoFile;
+ if ( !has_all ) {
+ // We provide nice warning message if the input is
+ // misconfigured.
+ auto warn = []( const char* env_var ) {
+ Catch::cerr()
+ << "Warning: Bazel shard configuration is missing '"
+ << env_var << "'. Shard configuration is skipped.\n";
+ };
+ if ( !bazelShardIndex ) {
+ warn( "TEST_SHARD_INDEX" );
+ }
+ if ( !bazelShardTotal ) {
+ warn( "TEST_TOTAL_SHARDS" );
+ }
+ if ( !bazelShardInfoFile ) {
+ warn( "TEST_SHARD_STATUS_FILE" );
+ }
+ return {};
+ }
+
+ auto shardIndex = parseUInt( bazelShardIndex );
+ if ( !shardIndex ) {
+ Catch::cerr()
+ << "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex
+ << "') as unsigned int.\n";
+ return {};
+ }
+ auto shardTotal = parseUInt( bazelShardTotal );
+ if ( !shardTotal ) {
+ Catch::cerr()
+ << "Warning: could not parse 'TEST_TOTAL_SHARD' ('"
+ << bazelShardTotal << "') as unsigned int.\n";
+ return {};
+ }
+
+ return bazelShardingOptions{
+ *shardIndex, *shardTotal, bazelShardInfoFile };
+
+ }
+ } // end namespace
+
+
+ bool operator==( ProcessedReporterSpec const& lhs,
+ ProcessedReporterSpec const& rhs ) {
+ return lhs.name == rhs.name &&
+ lhs.outputFilename == rhs.outputFilename &&
+ lhs.colourMode == rhs.colourMode &&
+ lhs.customOptions == rhs.customOptions;
+ }
+
+ Config::Config( ConfigData const& data ):
+ m_data( data ) {
+ // We need to trim filter specs to avoid trouble with superfluous
+ // whitespace (esp. important for bdd macros, as those are manually
+ // aligned with whitespace).
+
+ for (auto& elem : m_data.testsOrTags) {
+ elem = trim(elem);
+ }
+ for (auto& elem : m_data.sectionsToRun) {
+ elem = trim(elem);
+ }
+
+ // Insert the default reporter if user hasn't asked for a specific one
+ if ( m_data.reporterSpecifications.empty() ) {
+#if defined( CATCH_CONFIG_DEFAULT_REPORTER )
+ const auto default_spec = CATCH_CONFIG_DEFAULT_REPORTER;
+#else
+ const auto default_spec = "console";
+#endif
+ auto parsed = parseReporterSpec(default_spec);
+ CATCH_ENFORCE( parsed,
+ "Cannot parse the provided default reporter spec: '"
+ << default_spec << '\'' );
+ m_data.reporterSpecifications.push_back( std::move( *parsed ) );
+ }
+
+ if ( enableBazelEnvSupport() ) {
+ readBazelEnvVars();
+ }
+
+ // Bazel support can modify the test specs, so parsing has to happen
+ // after reading Bazel env vars.
+ TestSpecParser parser( ITagAliasRegistry::get() );
+ if ( !m_data.testsOrTags.empty() ) {
+ m_hasTestFilters = true;
+ for ( auto const& testOrTags : m_data.testsOrTags ) {
+ parser.parse( testOrTags );
+ }
+ }
+ m_testSpec = parser.testSpec();
+
+
+ // We now fixup the reporter specs to handle default output spec,
+ // default colour spec, etc
+ bool defaultOutputUsed = false;
+ for ( auto const& reporterSpec : m_data.reporterSpecifications ) {
+ // We do the default-output check separately, while always
+ // using the default output below to make the code simpler
+ // and avoid superfluous copies.
+ if ( reporterSpec.outputFile().none() ) {
+ CATCH_ENFORCE( !defaultOutputUsed,
+ "Internal error: cannot use default output for "
+ "multiple reporters" );
+ defaultOutputUsed = true;
+ }
+
+ m_processedReporterSpecs.push_back( ProcessedReporterSpec{
+ reporterSpec.name(),
+ reporterSpec.outputFile() ? *reporterSpec.outputFile()
+ : data.defaultOutputFilename,
+ reporterSpec.colourMode().valueOr( data.defaultColourMode ),
+ reporterSpec.customOptions() } );
+ }
+ }
+
+ Config::~Config() = default;
+
+
+ bool Config::listTests() const { return m_data.listTests; }
+ bool Config::listTags() const { return m_data.listTags; }
+ bool Config::listReporters() const { return m_data.listReporters; }
+ bool Config::listListeners() const { return m_data.listListeners; }
+
+ std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
+ std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
+
+ std::vector<ReporterSpec> const& Config::getReporterSpecs() const {
+ return m_data.reporterSpecifications;
+ }
+
+ std::vector<ProcessedReporterSpec> const&
+ Config::getProcessedReporterSpecs() const {
+ return m_processedReporterSpecs;
+ }
+
+ TestSpec const& Config::testSpec() const { return m_testSpec; }
+ bool Config::hasTestFilters() const { return m_hasTestFilters; }
+
+ bool Config::showHelp() const { return m_data.showHelp; }
+
+ // IConfig interface
+ bool Config::allowThrows() const { return !m_data.noThrow; }
+ StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
+ bool Config::includeSuccessfulResults() const { return m_data.showSuccessfulTests; }
+ bool Config::warnAboutMissingAssertions() const {
+ return !!( m_data.warnings & WarnAbout::NoAssertions );
+ }
+ bool Config::warnAboutUnmatchedTestSpecs() const {
+ return !!( m_data.warnings & WarnAbout::UnmatchedTestSpec );
+ }
+ bool Config::zeroTestsCountAsSuccess() const { return m_data.allowZeroTests; }
+ ShowDurations Config::showDurations() const { return m_data.showDurations; }
+ double Config::minDuration() const { return m_data.minDuration; }
+ TestRunOrder Config::runOrder() const { return m_data.runOrder; }
+ uint32_t Config::rngSeed() const { return m_data.rngSeed; }
+ unsigned int Config::shardCount() const { return m_data.shardCount; }
+ unsigned int Config::shardIndex() const { return m_data.shardIndex; }
+ ColourMode Config::defaultColourMode() const { return m_data.defaultColourMode; }
+ bool Config::shouldDebugBreak() const { return m_data.shouldDebugBreak; }
+ int Config::abortAfter() const { return m_data.abortAfter; }
+ bool Config::showInvisibles() const { return m_data.showInvisibles; }
+ Verbosity Config::verbosity() const { return m_data.verbosity; }
+
+ bool Config::skipBenchmarks() const { return m_data.skipBenchmarks; }
+ bool Config::benchmarkNoAnalysis() const { return m_data.benchmarkNoAnalysis; }
+ unsigned int Config::benchmarkSamples() const { return m_data.benchmarkSamples; }
+ double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; }
+ unsigned int Config::benchmarkResamples() const { return m_data.benchmarkResamples; }
+ std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+
+ void Config::readBazelEnvVars() {
+ // Register a JUnit reporter for Bazel. Bazel sets an environment
+ // variable with the path to XML output. If this file is written to
+ // during test, Bazel will not generate a default XML output.
+ // This allows the XML output file to contain higher level of detail
+ // than what is possible otherwise.
+ const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" );
+
+ if ( bazelOutputFile ) {
+ m_data.reporterSpecifications.push_back(
+ { "junit", std::string( bazelOutputFile ), {}, {} } );
+ }
+
+ const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" );
+ if ( bazelTestSpec ) {
+ // Presumably the test spec from environment should overwrite
+ // the one we got from CLI (if we got any)
+ m_data.testsOrTags.clear();
+ m_data.testsOrTags.push_back( bazelTestSpec );
+ }
+
+ const auto bazelShardOptions = readBazelShardingOptions();
+ if ( bazelShardOptions ) {
+ std::ofstream f( bazelShardOptions->shardFilePath,
+ std::ios_base::out | std::ios_base::trunc );
+ if ( f.is_open() ) {
+ f << "";
+ m_data.shardIndex = bazelShardOptions->shardIndex;
+ m_data.shardCount = bazelShardOptions->shardCount;
+ }
+ }
+ }
+
+} // end namespace Catch
+
+
+
+
+
+namespace Catch {
+ std::uint32_t getSeed() {
+ return getCurrentContext().getConfig()->rngSeed();
+ }
+}
+
+
+
+#include <cassert>
+#include <stack>
+
+namespace Catch {
+
+ ////////////////////////////////////////////////////////////////////////////
+
+
+ ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
+ m_info( CATCH_MOVE(builder.m_info) ) {
+ m_info.message = builder.m_stream.str();
+ getResultCapture().pushScopedMessage( m_info );
+ }
+
+ ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept:
+ m_info( CATCH_MOVE( old.m_info ) ) {
+ old.m_moved = true;
+ }
+
+ ScopedMessage::~ScopedMessage() {
+ if ( !uncaught_exceptions() && !m_moved ){
+ getResultCapture().popScopedMessage(m_info);
+ }
+ }
+
+
+ Capturer::Capturer( StringRef macroName,
+ SourceLineInfo const& lineInfo,
+ ResultWas::OfType resultType,
+ StringRef names ):
+ m_resultCapture( getResultCapture() ) {
+ auto trimmed = [&] (size_t start, size_t end) {
+ while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
+ ++start;
+ }
+ while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) {
+ --end;
+ }
+ return names.substr(start, end - start + 1);
+ };
+ auto skipq = [&] (size_t start, char quote) {
+ for (auto i = start + 1; i < names.size() ; ++i) {
+ if (names[i] == quote)
+ return i;
+ if (names[i] == '\\')
+ ++i;
+ }
+ CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+ };
+
+ size_t start = 0;
+ std::stack<char> openings;
+ for (size_t pos = 0; pos < names.size(); ++pos) {
+ char c = names[pos];
+ switch (c) {
+ case '[':
+ case '{':
+ case '(':
+ // It is basically impossible to disambiguate between
+ // comparison and start of template args in this context
+// case '<':
+ openings.push(c);
+ break;
+ case ']':
+ case '}':
+ case ')':
+// case '>':
+ openings.pop();
+ break;
+ case '"':
+ case '\'':
+ pos = skipq(pos, c);
+ break;
+ case ',':
+ if (start != pos && openings.empty()) {
+ m_messages.emplace_back(macroName, lineInfo, resultType);
+ m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+ m_messages.back().message += " := ";
+ start = pos;
+ }
+ default:; // noop
+ }
+ }
+ assert(openings.empty() && "Mismatched openings");
+ m_messages.emplace_back(macroName, lineInfo, resultType);
+ m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
+ m_messages.back().message += " := ";
+ }
+ Capturer::~Capturer() {
+ if ( !uncaught_exceptions() ){
+ assert( m_captured == m_messages.size() );
+ for( size_t i = 0; i < m_captured; ++i )
+ m_resultCapture.popScopedMessage( m_messages[i] );
+ }
+ }
+
+ void Capturer::captureValue( size_t index, std::string const& value ) {
+ assert( index < m_messages.size() );
+ m_messages[index].message += value;
+ m_resultCapture.pushScopedMessage( m_messages[index] );
+ m_captured++;
+ }
+
+} // end namespace Catch
+
+
+
+
+#include <exception>
+
+namespace Catch {
+
+ namespace {
+
+ class RegistryHub : public IRegistryHub,
+ public IMutableRegistryHub,
+ private Detail::NonCopyable {
+
+ public: // IRegistryHub
+ RegistryHub() = default;
+ ReporterRegistry const& getReporterRegistry() const override {
+ return m_reporterRegistry;
+ }
+ ITestCaseRegistry const& getTestCaseRegistry() const override {
+ return m_testCaseRegistry;
+ }
+ IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
+ return m_exceptionTranslatorRegistry;
+ }
+ ITagAliasRegistry const& getTagAliasRegistry() const override {
+ return m_tagAliasRegistry;
+ }
+ StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
+ return m_exceptionRegistry;
+ }
+
+ public: // IMutableRegistryHub
+ void registerReporter( std::string const& name, IReporterFactoryPtr factory ) override {
+ m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) );
+ }
+ void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) override {
+ m_reporterRegistry.registerListener( CATCH_MOVE(factory) );
+ }
+ void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker ) override {
+ m_testCaseRegistry.registerTest( CATCH_MOVE(testInfo), CATCH_MOVE(invoker) );
+ }
+ void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) override {
+ m_exceptionTranslatorRegistry.registerTranslator( CATCH_MOVE(translator) );
+ }
+ void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
+ m_tagAliasRegistry.add( alias, tag, lineInfo );
+ }
+ void registerStartupException() noexcept override {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+ m_exceptionRegistry.add(std::current_exception());
+#else
+ CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+#endif
+ }
+ IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
+ return m_enumValuesRegistry;
+ }
+
+ private:
+ TestRegistry m_testCaseRegistry;
+ ReporterRegistry m_reporterRegistry;
+ ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+ TagAliasRegistry m_tagAliasRegistry;
+ StartupExceptionRegistry m_exceptionRegistry;
+ Detail::EnumValuesRegistry m_enumValuesRegistry;
+ };
+ }
+
+ using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
+
+ IRegistryHub const& getRegistryHub() {
+ return RegistryHubSingleton::get();
+ }
+ IMutableRegistryHub& getMutableRegistryHub() {
+ return RegistryHubSingleton::getMutable();
+ }
+ void cleanUp() {
+ cleanupSingletons();
+ cleanUpContext();
+ }
+ std::string translateActiveException() {
+ return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+ }
+
+
+} // end namespace Catch
+
+
+
+#include <algorithm>
+#include <cassert>
+#include <exception>
+#include <iomanip>
+#include <set>
+
+namespace Catch {
+
+ namespace {
+ const int MaxExitCode = 255;
+
+ IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
+ auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
+ CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << '\'');
+
+ return reporter;
+ }
+
+ IEventListenerPtr prepareReporters(Config const* config) {
+ if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()
+ && config->getProcessedReporterSpecs().size() == 1) {
+ auto const& spec = config->getProcessedReporterSpecs()[0];
+ return createReporter(
+ spec.name,
+ ReporterConfig( config,
+ makeStream( spec.outputFilename ),
+ spec.colourMode,
+ spec.customOptions ) );
+ }
+
+ auto multi = Detail::make_unique<MultiReporter>(config);
+
+ auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+ for (auto const& listener : listeners) {
+ multi->addListener(listener->create(config));
+ }
+
+ for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) {
+ multi->addReporter( createReporter(
+ reporterSpec.name,
+ ReporterConfig( config,
+ makeStream( reporterSpec.outputFilename ),
+ reporterSpec.colourMode,
+ reporterSpec.customOptions ) ) );
+ }
+
+ return multi;
+ }
+
+ class TestGroup {
+ public:
+ explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
+ m_reporter(reporter.get()),
+ m_config{config},
+ m_context{config, CATCH_MOVE(reporter)} {
+
+ assert( m_config->testSpec().getInvalidSpecs().empty() &&
+ "Invalid test specs should be handled before running tests" );
+
+ auto const& allTestCases = getAllTestCasesSorted(*m_config);
+ auto const& testSpec = m_config->testSpec();
+ if ( !testSpec.hasFilters() ) {
+ for ( auto const& test : allTestCases ) {
+ if ( !test.getTestCaseInfo().isHidden() ) {
+ m_tests.emplace( &test );
+ }
+ }
+ } else {
+ m_matches =
+ testSpec.matchesByFilter( allTestCases, *m_config );
+ for ( auto const& match : m_matches ) {
+ m_tests.insert( match.tests.begin(),
+ match.tests.end() );
+ }
+ }
+
+ m_tests = createShard(m_tests, m_config->shardCount(), m_config->shardIndex());
+ }
+
+ Totals execute() {
+ Totals totals;
+ for (auto const& testCase : m_tests) {
+ if (!m_context.aborting())
+ totals += m_context.runTest(*testCase);
+ else
+ m_reporter->skipTest(testCase->getTestCaseInfo());
+ }
+
+ for (auto const& match : m_matches) {
+ if (match.tests.empty()) {
+ m_unmatchedTestSpecs = true;
+ m_reporter->noMatchingTestCases( match.name );
+ }
+ }
+
+ return totals;
+ }
+
+ bool hadUnmatchedTestSpecs() const {
+ return m_unmatchedTestSpecs;
+ }
+
+
+ private:
+ IEventListener* m_reporter;
+ Config const* m_config;
+ RunContext m_context;
+ std::set<TestCaseHandle const*> m_tests;
+ TestSpec::Matches m_matches;
+ bool m_unmatchedTestSpecs = false;
+ };
+
+ void applyFilenamesAsTags() {
+ for (auto const& testInfo : getRegistryHub().getTestCaseRegistry().getAllInfos()) {
+ testInfo->addFilenameTag();
+ }
+ }
+
+ } // anon namespace
+
+ Session::Session() {
+ static bool alreadyInstantiated = false;
+ if( alreadyInstantiated ) {
+ CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
+ CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
+ }
+
+ // There cannot be exceptions at startup in no-exception mode.
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+ const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
+ if ( !exceptions.empty() ) {
+ config();
+ getCurrentMutableContext().setConfig(m_config.get());
+
+ m_startupExceptions = true;
+ auto errStream = makeStream( "%stderr" );
+ auto colourImpl = makeColourImpl(
+ ColourMode::PlatformDefault, errStream.get() );
+ auto guard = colourImpl->guardColour( Colour::Red );
+ errStream->stream() << "Errors occurred during startup!" << '\n';
+ // iterate over all exceptions and notify user
+ for ( const auto& ex_ptr : exceptions ) {
+ try {
+ std::rethrow_exception(ex_ptr);
+ } catch ( std::exception const& ex ) {
+ errStream->stream() << TextFlow::Column( ex.what() ).indent(2) << '\n';
+ }
+ }
+ }
+#endif
+
+ alreadyInstantiated = true;
+ m_cli = makeCommandLineParser( m_configData );
+ }
+ Session::~Session() {
+ Catch::cleanUp();
+ }
+
+ void Session::showHelp() const {
+ Catch::cout()
+ << "\nCatch2 v" << libraryVersion() << '\n'
+ << m_cli << '\n'
+ << "For more detailed usage please see the project docs\n\n" << std::flush;
+ }
+ void Session::libIdentify() {
+ Catch::cout()
+ << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
+ << std::left << std::setw(16) << "category: " << "testframework\n"
+ << std::left << std::setw(16) << "framework: " << "Catch2\n"
+ << std::left << std::setw(16) << "version: " << libraryVersion() << '\n' << std::flush;
+ }
+
+ int Session::applyCommandLine( int argc, char const * const * argv ) {
+ if( m_startupExceptions )
+ return 1;
+
+ auto result = m_cli.parse( Clara::Args( argc, argv ) );
+
+ if( !result ) {
+ config();
+ getCurrentMutableContext().setConfig(m_config.get());
+ auto errStream = makeStream( "%stderr" );
+ auto colour = makeColourImpl( ColourMode::PlatformDefault, errStream.get() );
+
+ errStream->stream()
+ << colour->guardColour( Colour::Red )
+ << "\nError(s) in input:\n"
+ << TextFlow::Column( result.errorMessage() ).indent( 2 )
+ << "\n\n";
+ errStream->stream() << "Run with -? for usage\n\n" << std::flush;
+ return MaxExitCode;
+ }
+
+ if( m_configData.showHelp )
+ showHelp();
+ if( m_configData.libIdentify )
+ libIdentify();
+
+ m_config.reset();
+ return 0;
+ }
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+ int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
+
+ char **utf8Argv = new char *[ argc ];
+
+ for ( int i = 0; i < argc; ++i ) {
+ int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
+
+ utf8Argv[ i ] = new char[ bufSize ];
+
+ WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
+ }
+
+ int returnCode = applyCommandLine( argc, utf8Argv );
+
+ for ( int i = 0; i < argc; ++i )
+ delete [] utf8Argv[ i ];
+
+ delete [] utf8Argv;
+
+ return returnCode;
+ }
+#endif
+
+ void Session::useConfigData( ConfigData const& configData ) {
+ m_configData = configData;
+ m_config.reset();
+ }
+
+ int Session::run() {
+ if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+ Catch::cout() << "...waiting for enter/ return before starting\n" << std::flush;
+ static_cast<void>(std::getchar());
+ }
+ int exitCode = runInternal();
+ if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+ Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << '\n' << std::flush;
+ static_cast<void>(std::getchar());
+ }
+ return exitCode;
+ }
+
+ Clara::Parser const& Session::cli() const {
+ return m_cli;
+ }
+ void Session::cli( Clara::Parser const& newParser ) {
+ m_cli = newParser;
+ }
+ ConfigData& Session::configData() {
+ return m_configData;
+ }
+ Config& Session::config() {
+ if( !m_config )
+ m_config = Detail::make_unique<Config>( m_configData );
+ return *m_config;
+ }
+
+ int Session::runInternal() {
+ if( m_startupExceptions )
+ return 1;
+
+ if (m_configData.showHelp || m_configData.libIdentify) {
+ return 0;
+ }
+
+ if ( m_configData.shardIndex >= m_configData.shardCount ) {
+ Catch::cerr() << "The shard count (" << m_configData.shardCount
+ << ") must be greater than the shard index ("
+ << m_configData.shardIndex << ")\n"
+ << std::flush;
+ return 1;
+ }
+
+ CATCH_TRY {
+ config(); // Force config to be constructed
+
+ seedRng( *m_config );
+
+ if (m_configData.filenamesAsTags) {
+ applyFilenamesAsTags();
+ }
+
+ // Set up global config instance before we start calling into other functions
+ getCurrentMutableContext().setConfig(m_config.get());
+
+ // Create reporter(s) so we can route listings through them
+ auto reporter = prepareReporters(m_config.get());
+
+ auto const& invalidSpecs = m_config->testSpec().getInvalidSpecs();
+ if ( !invalidSpecs.empty() ) {
+ for ( auto const& spec : invalidSpecs ) {
+ reporter->reportInvalidTestSpec( spec );
+ }
+ return 1;
+ }
+
+
+ // Handle list request
+ if (list(*reporter, *m_config)) {
+ return 0;
+ }
+
+ TestGroup tests { CATCH_MOVE(reporter), m_config.get() };
+ auto const totals = tests.execute();
+
+ if ( tests.hadUnmatchedTestSpecs()
+ && m_config->warnAboutUnmatchedTestSpecs() ) {
+ return 3;
+ }
+
+ if ( totals.testCases.total() == 0
+ && !m_config->zeroTestsCountAsSuccess() ) {
+ return 2;
+ }
+
+ if ( totals.testCases.total() > 0 &&
+ totals.testCases.total() == totals.testCases.skipped
+ && !m_config->zeroTestsCountAsSuccess() ) {
+ return 4;
+ }
+
+ // Note that on unices only the lower 8 bits are usually used, clamping
+ // the return value to 255 prevents false negative when some multiple
+ // of 256 tests has failed
+ return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed));
+ }
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+ catch( std::exception& ex ) {
+ Catch::cerr() << ex.what() << '\n' << std::flush;
+ return MaxExitCode;
+ }
+#endif
+ }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+
+ RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
+ CATCH_TRY {
+ getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
+ } CATCH_CATCH_ALL {
+ // Do not throw when constructing global objects, instead register the exception to be processed later
+ getMutableRegistryHub().registerStartupException();
+ }
+ }
+
+}
+
+
+
+#include <cassert>
+#include <cctype>
+#include <algorithm>
+
+namespace Catch {
+
+ namespace {
+ using TCP_underlying_type = uint8_t;
+ static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type),
+ "The size of the TestCaseProperties is different from the assumed size");
+
+ TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
+ return static_cast<TestCaseProperties>(
+ static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
+ );
+ }
+
+ TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
+ lhs = static_cast<TestCaseProperties>(
+ static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
+ );
+ return lhs;
+ }
+
+ TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
+ return static_cast<TestCaseProperties>(
+ static_cast<TCP_underlying_type>(lhs) & static_cast<TCP_underlying_type>(rhs)
+ );
+ }
+
+ bool applies(TestCaseProperties tcp) {
+ static_assert(static_cast<TCP_underlying_type>(TestCaseProperties::None) == 0,
+ "TestCaseProperties::None must be equal to 0");
+ return tcp != TestCaseProperties::None;
+ }
+
+ TestCaseProperties parseSpecialTag( StringRef tag ) {
+ if( !tag.empty() && tag[0] == '.' )
+ return TestCaseProperties::IsHidden;
+ else if( tag == "!throws"_sr )
+ return TestCaseProperties::Throws;
+ else if( tag == "!shouldfail"_sr )
+ return TestCaseProperties::ShouldFail;
+ else if( tag == "!mayfail"_sr )
+ return TestCaseProperties::MayFail;
+ else if( tag == "!nonportable"_sr )
+ return TestCaseProperties::NonPortable;
+ else if( tag == "!benchmark"_sr )
+ return TestCaseProperties::Benchmark | TestCaseProperties::IsHidden;
+ else
+ return TestCaseProperties::None;
+ }
+ bool isReservedTag( StringRef tag ) {
+ return parseSpecialTag( tag ) == TestCaseProperties::None
+ && tag.size() > 0
+ && !std::isalnum( static_cast<unsigned char>(tag[0]) );
+ }
+ void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _lineInfo ) {
+ CATCH_ENFORCE( !isReservedTag(tag),
+ "Tag name: [" << tag << "] is not allowed.\n"
+ << "Tag names starting with non alphanumeric characters are reserved\n"
+ << _lineInfo );
+ }
+
+ std::string makeDefaultName() {
+ static size_t counter = 0;
+ return "Anonymous test case " + std::to_string(++counter);
+ }
+
+ StringRef extractFilenamePart(StringRef filename) {
+ size_t lastDot = filename.size();
+ while (lastDot > 0 && filename[lastDot - 1] != '.') {
+ --lastDot;
+ }
+ // In theory we could have filename without any extension in it
+ if ( lastDot == 0 ) { return StringRef(); }
+
+ --lastDot;
+ size_t nameStart = lastDot;
+ while (nameStart > 0 && filename[nameStart - 1] != '/' && filename[nameStart - 1] != '\\') {
+ --nameStart;
+ }
+
+ return filename.substr(nameStart, lastDot - nameStart);
+ }
+
+ // Returns the upper bound on size of extra tags ([#file]+[.])
+ size_t sizeOfExtraTags(StringRef filepath) {
+ // [.] is 3, [#] is another 3
+ const size_t extras = 3 + 3;
+ return extractFilenamePart(filepath).size() + extras;
+ }
+ } // end unnamed namespace
+
+ bool operator<( Tag const& lhs, Tag const& rhs ) {
+ Detail::CaseInsensitiveLess cmp;
+ return cmp( lhs.original, rhs.original );
+ }
+ bool operator==( Tag const& lhs, Tag const& rhs ) {
+ Detail::CaseInsensitiveEqualTo cmp;
+ return cmp( lhs.original, rhs.original );
+ }
+
+ Detail::unique_ptr<TestCaseInfo>
+ makeTestCaseInfo(StringRef _className,
+ NameAndTags const& nameAndTags,
+ SourceLineInfo const& _lineInfo ) {
+ return Detail::make_unique<TestCaseInfo>(_className, nameAndTags, _lineInfo);
+ }
+
+ TestCaseInfo::TestCaseInfo(StringRef _className,
+ NameAndTags const& _nameAndTags,
+ SourceLineInfo const& _lineInfo):
+ name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ),
+ className( _className ),
+ lineInfo( _lineInfo )
+ {
+ StringRef originalTags = _nameAndTags.tags;
+ // We need to reserve enough space to store all of the tags
+ // (including optional hidden tag and filename tag)
+ auto requiredSize = originalTags.size() + sizeOfExtraTags(_lineInfo.file);
+ backingTags.reserve(requiredSize);
+
+ // We cannot copy the tags directly, as we need to normalize
+ // some tags, so that [.foo] is copied as [.][foo].
+ size_t tagStart = 0;
+ size_t tagEnd = 0;
+ bool inTag = false;
+ for (size_t idx = 0; idx < originalTags.size(); ++idx) {
+ auto c = originalTags[idx];
+ if (c == '[') {
+ CATCH_ENFORCE(
+ !inTag,
+ "Found '[' inside a tag while registering test case '"
+ << _nameAndTags.name << "' at " << _lineInfo );
+
+ inTag = true;
+ tagStart = idx;
+ }
+ if (c == ']') {
+ CATCH_ENFORCE(
+ inTag,
+ "Found unmatched ']' while registering test case '"
+ << _nameAndTags.name << "' at " << _lineInfo );
+
+ inTag = false;
+ tagEnd = idx;
+ assert(tagStart < tagEnd);
+
+ // We need to check the tag for special meanings, copy
+ // it over to backing storage and actually reference the
+ // backing storage in the saved tags
+ StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
+ CATCH_ENFORCE( !tagStr.empty(),
+ "Found an empty tag while registering test case '"
+ << _nameAndTags.name << "' at "
+ << _lineInfo );
+
+ enforceNotReservedTag(tagStr, lineInfo);
+ properties |= parseSpecialTag(tagStr);
+ // When copying a tag to the backing storage, we need to
+ // check if it is a merged hide tag, such as [.foo], and
+ // if it is, we need to handle it as if it was [foo].
+ if (tagStr.size() > 1 && tagStr[0] == '.') {
+ tagStr = tagStr.substr(1, tagStr.size() - 1);
+ }
+ // We skip over dealing with the [.] tag, as we will add
+ // it later unconditionally and then sort and unique all
+ // the tags.
+ internalAppendTag(tagStr);
+ }
+ }
+ CATCH_ENFORCE( !inTag,
+ "Found an unclosed tag while registering test case '"
+ << _nameAndTags.name << "' at " << _lineInfo );
+
+
+ // Add [.] if relevant
+ if (isHidden()) {
+ internalAppendTag("."_sr);
+ }
+
+ // Sort and prepare tags
+ std::sort(begin(tags), end(tags));
+ tags.erase(std::unique(begin(tags), end(tags)),
+ end(tags));
+ }
+
+ bool TestCaseInfo::isHidden() const {
+ return applies( properties & TestCaseProperties::IsHidden );
+ }
+ bool TestCaseInfo::throws() const {
+ return applies( properties & TestCaseProperties::Throws );
+ }
+ bool TestCaseInfo::okToFail() const {
+ return applies( properties & (TestCaseProperties::ShouldFail | TestCaseProperties::MayFail ) );
+ }
+ bool TestCaseInfo::expectedToFail() const {
+ return applies( properties & (TestCaseProperties::ShouldFail) );
+ }
+
+ void TestCaseInfo::addFilenameTag() {
+ std::string combined("#");
+ combined += extractFilenamePart(lineInfo.file);
+ internalAppendTag(combined);
+ }
+
+ std::string TestCaseInfo::tagsAsString() const {
+ std::string ret;
+ // '[' and ']' per tag
+ std::size_t full_size = 2 * tags.size();
+ for (const auto& tag : tags) {
+ full_size += tag.original.size();
+ }
+ ret.reserve(full_size);
+ for (const auto& tag : tags) {
+ ret.push_back('[');
+ ret += tag.original;
+ ret.push_back(']');
+ }
+
+ return ret;
+ }
+
+ void TestCaseInfo::internalAppendTag(StringRef tagStr) {
+ backingTags += '[';
+ const auto backingStart = backingTags.size();
+ backingTags += tagStr;
+ const auto backingEnd = backingTags.size();
+ backingTags += ']';
+ tags.emplace_back(StringRef(backingTags.c_str() + backingStart, backingEnd - backingStart));
+ }
+
+ bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) {
+ // We want to avoid redoing the string comparisons multiple times,
+ // so we store the result of a three-way comparison before using
+ // it in the actual comparison logic.
+ const auto cmpName = lhs.name.compare( rhs.name );
+ if ( cmpName != 0 ) {
+ return cmpName < 0;
+ }
+ const auto cmpClassName = lhs.className.compare( rhs.className );
+ if ( cmpClassName != 0 ) {
+ return cmpClassName < 0;
+ }
+ return lhs.tags < rhs.tags;
+ }
+
+ TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const {
+ return *m_info;
+ }
+
+} // end namespace Catch
+
+
+
+#include <algorithm>
+#include <string>
+#include <vector>
+#include <ostream>
+
+namespace Catch {
+
+ TestSpec::Pattern::Pattern( std::string const& name )
+ : m_name( name )
+ {}
+
+ TestSpec::Pattern::~Pattern() = default;
+
+ std::string const& TestSpec::Pattern::name() const {
+ return m_name;
+ }
+
+
+ TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
+ : Pattern( filterString )
+ , m_wildcardPattern( toLower( name ), CaseSensitive::No )
+ {}
+
+ bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
+ return m_wildcardPattern.matches( testCase.name );
+ }
+
+ void TestSpec::NamePattern::serializeTo( std::ostream& out ) const {
+ out << '"' << name() << '"';
+ }
+
+
+ TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
+ : Pattern( filterString )
+ , m_tag( tag )
+ {}
+
+ bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
+ return std::find( begin( testCase.tags ),
+ end( testCase.tags ),
+ Tag( m_tag ) ) != end( testCase.tags );
+ }
+
+ void TestSpec::TagPattern::serializeTo( std::ostream& out ) const {
+ out << name();
+ }
+
+ bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
+ bool should_use = !testCase.isHidden();
+ for (auto const& pattern : m_required) {
+ should_use = true;
+ if (!pattern->matches(testCase)) {
+ return false;
+ }
+ }
+ for (auto const& pattern : m_forbidden) {
+ if (pattern->matches(testCase)) {
+ return false;
+ }
+ }
+ return should_use;
+ }
+
+ void TestSpec::Filter::serializeTo( std::ostream& out ) const {
+ bool first = true;
+ for ( auto const& pattern : m_required ) {
+ if ( !first ) {
+ out << ' ';
+ }
+ out << *pattern;
+ first = false;
+ }
+ for ( auto const& pattern : m_forbidden ) {
+ if ( !first ) {
+ out << ' ';
+ }
+ out << *pattern;
+ first = false;
+ }
+ }
+
+
+ std::string TestSpec::extractFilterName( Filter const& filter ) {
+ Catch::ReusableStringStream sstr;
+ sstr << filter;
+ return sstr.str();
+ }
+
+ bool TestSpec::hasFilters() const {
+ return !m_filters.empty();
+ }
+
+ bool TestSpec::matches( TestCaseInfo const& testCase ) const {
+ return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
+ }
+
+ TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const {
+ Matches matches;
+ matches.reserve( m_filters.size() );
+ for ( auto const& filter : m_filters ) {
+ std::vector<TestCaseHandle const*> currentMatches;
+ for ( auto const& test : testCases )
+ if ( isThrowSafe( test, config ) &&
+ filter.matches( test.getTestCaseInfo() ) )
+ currentMatches.emplace_back( &test );
+ matches.push_back(
+ FilterMatch{ extractFilterName( filter ), currentMatches } );
+ }
+ return matches;
+ }
+
+ const TestSpec::vectorStrings& TestSpec::getInvalidSpecs() const {
+ return m_invalidSpecs;
+ }
+
+ void TestSpec::serializeTo( std::ostream& out ) const {
+ bool first = true;
+ for ( auto const& filter : m_filters ) {
+ if ( !first ) {
+ out << ',';
+ }
+ out << filter;
+ first = false;
+ }
+ }
+
+}
+
+
+
+#include <chrono>
+
+namespace Catch {
+
+ namespace {
+ static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
+ return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+ }
+ } // end unnamed namespace
+
+ void Timer::start() {
+ m_nanoseconds = getCurrentNanosecondsSinceEpoch();
+ }
+ auto Timer::getElapsedNanoseconds() const -> uint64_t {
+ return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
+ }
+ auto Timer::getElapsedMicroseconds() const -> uint64_t {
+ return getElapsedNanoseconds()/1000;
+ }
+ auto Timer::getElapsedMilliseconds() const -> unsigned int {
+ return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+ }
+ auto Timer::getElapsedSeconds() const -> double {
+ return getElapsedMicroseconds()/1000000.0;
+ }
+
+
+} // namespace Catch
+
+
+
+
+#include <cmath>
+#include <iomanip>
+
+namespace Catch {
+
+namespace Detail {
+
+ namespace {
+ const int hexThreshold = 255;
+
+ struct Endianness {
+ enum Arch { Big, Little };
+
+ static Arch which() {
+ int one = 1;
+ // If the lowest byte we read is non-zero, we can assume
+ // that little endian format is used.
+ auto value = *reinterpret_cast<char*>(&one);
+ return value ? Little : Big;
+ }
+ };
+
+ template<typename T>
+ std::string fpToString(T value, int precision) {
+ if (Catch::isnan(value)) {
+ return "nan";
+ }
+
+ ReusableStringStream rss;
+ rss << std::setprecision(precision)
+ << std::fixed
+ << value;
+ std::string d = rss.str();
+ std::size_t i = d.find_last_not_of('0');
+ if (i != std::string::npos && i != d.size() - 1) {
+ if (d[i] == '.')
+ i++;
+ d = d.substr(0, i + 1);
+ }
+ return d;
+ }
+ } // end unnamed namespace
+
+ std::string convertIntoString(StringRef string, bool escapeInvisibles) {
+ std::string ret;
+ // This is enough for the "don't escape invisibles" case, and a good
+ // lower bound on the "escape invisibles" case.
+ ret.reserve(string.size() + 2);
+
+ if (!escapeInvisibles) {
+ ret += '"';
+ ret += string;
+ ret += '"';
+ return ret;
+ }
+
+ ret += '"';
+ for (char c : string) {
+ switch (c) {
+ case '\r':
+ ret.append("\\r");
+ break;
+ case '\n':
+ ret.append("\\n");
+ break;
+ case '\t':
+ ret.append("\\t");
+ break;
+ case '\f':
+ ret.append("\\f");
+ break;
+ default:
+ ret.push_back(c);
+ break;
+ }
+ }
+ ret += '"';
+
+ return ret;
+ }
+
+ std::string convertIntoString(StringRef string) {
+ return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles());
+ }
+
+ std::string rawMemoryToString( const void *object, std::size_t size ) {
+ // Reverse order for little endian architectures
+ int i = 0, end = static_cast<int>( size ), inc = 1;
+ if( Endianness::which() == Endianness::Little ) {
+ i = end-1;
+ end = inc = -1;
+ }
+
+ unsigned char const *bytes = static_cast<unsigned char const *>(object);
+ ReusableStringStream rss;
+ rss << "0x" << std::setfill('0') << std::hex;
+ for( ; i != end; i += inc )
+ rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
+ return rss.str();
+ }
+} // end Detail namespace
+
+
+
+//// ======================================================= ////
+//
+// Out-of-line defs for full specialization of StringMaker
+//
+//// ======================================================= ////
+
+std::string StringMaker<std::string>::convert(const std::string& str) {
+ return Detail::convertIntoString( str );
+}
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::string_view>::convert(std::string_view str) {
+ return Detail::convertIntoString( StringRef( str.data(), str.size() ) );
+}
+#endif
+
+std::string StringMaker<char const*>::convert(char const* str) {
+ if (str) {
+ return Detail::convertIntoString( str );
+ } else {
+ return{ "{null string}" };
+ }
+}
+std::string StringMaker<char*>::convert(char* str) { // NOLINT(readability-non-const-parameter)
+ if (str) {
+ return Detail::convertIntoString( str );
+ } else {
+ return{ "{null string}" };
+ }
+}
+
+#ifdef CATCH_CONFIG_WCHAR
+std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
+ std::string s;
+ s.reserve(wstr.size());
+ for (auto c : wstr) {
+ s += (c <= 0xff) ? static_cast<char>(c) : '?';
+ }
+ return ::Catch::Detail::stringify(s);
+}
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
+ return StringMaker<std::wstring>::convert(std::wstring(str));
+}
+# endif
+
+std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
+ if (str) {
+ return ::Catch::Detail::stringify(std::wstring{ str });
+ } else {
+ return{ "{null string}" };
+ }
+}
+std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
+ if (str) {
+ return ::Catch::Detail::stringify(std::wstring{ str });
+ } else {
+ return{ "{null string}" };
+ }
+}
+#endif
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+#include <cstddef>
+std::string StringMaker<std::byte>::convert(std::byte value) {
+ return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
+}
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+
+std::string StringMaker<int>::convert(int value) {
+ return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long>::convert(long value) {
+ return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long long>::convert(long long value) {
+ ReusableStringStream rss;
+ rss << value;
+ if (value > Detail::hexThreshold) {
+ rss << " (0x" << std::hex << value << ')';
+ }
+ return rss.str();
+}
+
+std::string StringMaker<unsigned int>::convert(unsigned int value) {
+ return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long>::convert(unsigned long value) {
+ return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
+ ReusableStringStream rss;
+ rss << value;
+ if (value > Detail::hexThreshold) {
+ rss << " (0x" << std::hex << value << ')';
+ }
+ return rss.str();
+}
+
+std::string StringMaker<signed char>::convert(signed char value) {
+ if (value == '\r') {
+ return "'\\r'";
+ } else if (value == '\f') {
+ return "'\\f'";
+ } else if (value == '\n') {
+ return "'\\n'";
+ } else if (value == '\t') {
+ return "'\\t'";
+ } else if ('\0' <= value && value < ' ') {
+ return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
+ } else {
+ char chstr[] = "' '";
+ chstr[1] = value;
+ return chstr;
+ }
+}
+std::string StringMaker<char>::convert(char c) {
+ return ::Catch::Detail::stringify(static_cast<signed char>(c));
+}
+std::string StringMaker<unsigned char>::convert(unsigned char value) {
+ return ::Catch::Detail::stringify(static_cast<char>(value));
+}
+
+int StringMaker<float>::precision = std::numeric_limits<float>::max_digits10;
+
+std::string StringMaker<float>::convert(float value) {
+ return Detail::fpToString(value, precision) + 'f';
+}
+
+int StringMaker<double>::precision = std::numeric_limits<double>::max_digits10;
+
+std::string StringMaker<double>::convert(double value) {
+ return Detail::fpToString(value, precision);
+}
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+ Counts Counts::operator - ( Counts const& other ) const {
+ Counts diff;
+ diff.passed = passed - other.passed;
+ diff.failed = failed - other.failed;
+ diff.failedButOk = failedButOk - other.failedButOk;
+ diff.skipped = skipped - other.skipped;
+ return diff;
+ }
+
+ Counts& Counts::operator += ( Counts const& other ) {
+ passed += other.passed;
+ failed += other.failed;
+ failedButOk += other.failedButOk;
+ skipped += other.skipped;
+ return *this;
+ }
+
+ std::uint64_t Counts::total() const {
+ return passed + failed + failedButOk + skipped;
+ }
+ bool Counts::allPassed() const {
+ return failed == 0 && failedButOk == 0 && skipped == 0;
+ }
+ bool Counts::allOk() const {
+ return failed == 0;
+ }
+
+ Totals Totals::operator - ( Totals const& other ) const {
+ Totals diff;
+ diff.assertions = assertions - other.assertions;
+ diff.testCases = testCases - other.testCases;
+ return diff;
+ }
+
+ Totals& Totals::operator += ( Totals const& other ) {
+ assertions += other.assertions;
+ testCases += other.testCases;
+ return *this;
+ }
+
+ Totals Totals::delta( Totals const& prevTotals ) const {
+ Totals diff = *this - prevTotals;
+ if( diff.assertions.failed > 0 )
+ ++diff.testCases.failed;
+ else if( diff.assertions.failedButOk > 0 )
+ ++diff.testCases.failedButOk;
+ else if ( diff.assertions.skipped > 0 )
+ ++ diff.testCases.skipped;
+ else
+ ++diff.testCases.passed;
+ return diff;
+ }
+
+}
+
+
+
+
+namespace Catch {
+ namespace Detail {
+ void registerTranslatorImpl(
+ Detail::unique_ptr<IExceptionTranslator>&& translator ) {
+ getMutableRegistryHub().registerTranslator(
+ CATCH_MOVE( translator ) );
+ }
+ } // namespace Detail
+} // namespace Catch
+
+
+#include <ostream>
+
+namespace Catch {
+
+ Version::Version
+ ( unsigned int _majorVersion,
+ unsigned int _minorVersion,
+ unsigned int _patchNumber,
+ char const * const _branchName,
+ unsigned int _buildNumber )
+ : majorVersion( _majorVersion ),
+ minorVersion( _minorVersion ),
+ patchNumber( _patchNumber ),
+ branchName( _branchName ),
+ buildNumber( _buildNumber )
+ {}
+
+ std::ostream& operator << ( std::ostream& os, Version const& version ) {
+ os << version.majorVersion << '.'
+ << version.minorVersion << '.'
+ << version.patchNumber;
+ // branchName is never null -> 0th char is \0 if it is empty
+ if (version.branchName[0]) {
+ os << '-' << version.branchName
+ << '.' << version.buildNumber;
+ }
+ return os;
+ }
+
+ Version const& libraryVersion() {
+ static Version version( 3, 6, 0, "", 0 );
+ return version;
+ }
+
+}
+
+
+
+
+namespace Catch {
+
+ const char* GeneratorException::what() const noexcept {
+ return m_msg;
+ }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+
+ IGeneratorTracker::~IGeneratorTracker() = default;
+
+namespace Generators {
+
+namespace Detail {
+
+ [[noreturn]]
+ void throw_generator_exception(char const* msg) {
+ Catch::throw_exception(GeneratorException{ msg });
+ }
+} // end namespace Detail
+
+ GeneratorUntypedBase::~GeneratorUntypedBase() = default;
+
+ IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) {
+ return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
+ }
+
+ IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+ SourceLineInfo lineInfo,
+ GeneratorBasePtr&& generator ) {
+ return getResultCapture().createGeneratorTracker(
+ generatorName, lineInfo, CATCH_MOVE( generator ) );
+ }
+
+} // namespace Generators
+} // namespace Catch
+
+
+
+
+#include <random>
+
+namespace Catch {
+ namespace Generators {
+ namespace Detail {
+ std::uint32_t getSeed() { return sharedRng()(); }
+ } // namespace Detail
+
+ struct RandomFloatingGenerator<long double>::PImpl {
+ PImpl( long double a, long double b, uint32_t seed ):
+ rng( seed ), dist( a, b ) {}
+
+ Catch::SimplePcg32 rng;
+ std::uniform_real_distribution<long double> dist;
+ };
+
+ RandomFloatingGenerator<long double>::RandomFloatingGenerator(
+ long double a, long double b, std::uint32_t seed) :
+ m_pimpl(Catch::Detail::make_unique<PImpl>(a, b, seed)) {
+ static_cast<void>( next() );
+ }
+
+ RandomFloatingGenerator<long double>::~RandomFloatingGenerator() =
+ default;
+ bool RandomFloatingGenerator<long double>::next() {
+ m_current_number = m_pimpl->dist( m_pimpl->rng );
+ return true;
+ }
+ } // namespace Generators
+} // namespace Catch
+
+
+
+
+namespace Catch {
+ IResultCapture::~IResultCapture() = default;
+}
+
+
+
+
+namespace Catch {
+ IConfig::~IConfig() = default;
+}
+
+
+
+
+namespace Catch {
+ IExceptionTranslator::~IExceptionTranslator() = default;
+ IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
+}
+
+
+
+#include <string>
+
+namespace Catch {
+ namespace Generators {
+
+ bool GeneratorUntypedBase::countedNext() {
+ auto ret = next();
+ if ( ret ) {
+ m_stringReprCache.clear();
+ ++m_currentElementIndex;
+ }
+ return ret;
+ }
+
+ StringRef GeneratorUntypedBase::currentElementAsString() const {
+ if ( m_stringReprCache.empty() ) {
+ m_stringReprCache = stringifyImpl();
+ }
+ return m_stringReprCache;
+ }
+
+ } // namespace Generators
+} // namespace Catch
+
+
+
+
+namespace Catch {
+ IRegistryHub::~IRegistryHub() = default;
+ IMutableRegistryHub::~IMutableRegistryHub() = default;
+}
+
+
+
+#include <cassert>
+
+namespace Catch {
+
+ ReporterConfig::ReporterConfig(
+ IConfig const* _fullConfig,
+ Detail::unique_ptr<IStream> _stream,
+ ColourMode colourMode,
+ std::map<std::string, std::string> customOptions ):
+ m_stream( CATCH_MOVE(_stream) ),
+ m_fullConfig( _fullConfig ),
+ m_colourMode( colourMode ),
+ m_customOptions( CATCH_MOVE( customOptions ) ) {}
+
+ Detail::unique_ptr<IStream> ReporterConfig::takeStream() && {
+ assert( m_stream );
+ return CATCH_MOVE( m_stream );
+ }
+ IConfig const * ReporterConfig::fullConfig() const { return m_fullConfig; }
+ ColourMode ReporterConfig::colourMode() const { return m_colourMode; }
+
+ std::map<std::string, std::string> const&
+ ReporterConfig::customOptions() const {
+ return m_customOptions;
+ }
+
+ ReporterConfig::~ReporterConfig() = default;
+
+ AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
+ std::vector<MessageInfo> const& _infoMessages,
+ Totals const& _totals )
+ : assertionResult( _assertionResult ),
+ infoMessages( _infoMessages ),
+ totals( _totals )
+ {
+ if( assertionResult.hasMessage() ) {
+ // Copy message into messages list.
+ // !TBD This should have been done earlier, somewhere
+ MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+ builder.m_info.message = static_cast<std::string>(assertionResult.getMessage());
+
+ infoMessages.push_back( CATCH_MOVE(builder.m_info) );
+ }
+ }
+
+ SectionStats::SectionStats( SectionInfo&& _sectionInfo,
+ Counts const& _assertions,
+ double _durationInSeconds,
+ bool _missingAssertions )
+ : sectionInfo( CATCH_MOVE(_sectionInfo) ),
+ assertions( _assertions ),
+ durationInSeconds( _durationInSeconds ),
+ missingAssertions( _missingAssertions )
+ {}
+
+
+ TestCaseStats::TestCaseStats( TestCaseInfo const& _testInfo,
+ Totals const& _totals,
+ std::string&& _stdOut,
+ std::string&& _stdErr,
+ bool _aborting )
+ : testInfo( &_testInfo ),
+ totals( _totals ),
+ stdOut( CATCH_MOVE(_stdOut) ),
+ stdErr( CATCH_MOVE(_stdErr) ),
+ aborting( _aborting )
+ {}
+
+
+ TestRunStats::TestRunStats( TestRunInfo const& _runInfo,
+ Totals const& _totals,
+ bool _aborting )
+ : runInfo( _runInfo ),
+ totals( _totals ),
+ aborting( _aborting )
+ {}
+
+ IEventListener::~IEventListener() = default;
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+ IReporterFactory::~IReporterFactory() = default;
+ EventListenerFactory::~EventListenerFactory() = default;
+}
+
+
+
+
+namespace Catch {
+ ITestCaseRegistry::~ITestCaseRegistry() = default;
+}
+
+
+
+namespace Catch {
+
+ AssertionHandler::AssertionHandler
+ ( StringRef macroName,
+ SourceLineInfo const& lineInfo,
+ StringRef capturedExpression,
+ ResultDisposition::Flags resultDisposition )
+ : m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
+ m_resultCapture( getResultCapture() )
+ {
+ m_resultCapture.notifyAssertionStarted( m_assertionInfo );
+ }
+
+ void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
+ m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
+ }
+ void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef message) {
+ m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
+ }
+
+ auto AssertionHandler::allowThrows() const -> bool {
+ return getCurrentContext().getConfig()->allowThrows();
+ }
+
+ void AssertionHandler::complete() {
+ m_completed = true;
+ if( m_reaction.shouldDebugBreak ) {
+
+ // If you find your debugger stopping you here then go one level up on the
+ // call-stack for the code that caused it (typically a failed assertion)
+
+ // (To go back to the test and change execution, jump over the throw, next)
+ CATCH_BREAK_INTO_DEBUGGER();
+ }
+ if (m_reaction.shouldThrow) {
+ throw_test_failure_exception();
+ }
+ if ( m_reaction.shouldSkip ) {
+ throw_test_skip_exception();
+ }
+ }
+
+ void AssertionHandler::handleUnexpectedInflightException() {
+ m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
+ }
+
+ void AssertionHandler::handleExceptionThrownAsExpected() {
+ m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+ }
+ void AssertionHandler::handleExceptionNotThrownAsExpected() {
+ m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+ }
+
+ void AssertionHandler::handleUnexpectedExceptionNotThrown() {
+ m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
+ }
+
+ void AssertionHandler::handleThrowingCallSkipped() {
+ m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+ }
+
+ // This is the overload that takes a string and infers the Equals matcher from it
+ // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
+ void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ) {
+ handleExceptionMatchExpr( handler, Matchers::Equals( str ) );
+ }
+
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+
+namespace Catch {
+ namespace Detail {
+
+ bool CaseInsensitiveLess::operator()( StringRef lhs,
+ StringRef rhs ) const {
+ return std::lexicographical_compare(
+ lhs.begin(), lhs.end(),
+ rhs.begin(), rhs.end(),
+ []( char l, char r ) { return toLower( l ) < toLower( r ); } );
+ }
+
+ bool
+ CaseInsensitiveEqualTo::operator()( StringRef lhs,
+ StringRef rhs ) const {
+ return std::equal(
+ lhs.begin(), lhs.end(),
+ rhs.begin(), rhs.end(),
+ []( char l, char r ) { return toLower( l ) == toLower( r ); } );
+ }
+
+ } // namespace Detail
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+#include <ostream>
+
+namespace {
+ bool isOptPrefix( char c ) {
+ return c == '-'
+#ifdef CATCH_PLATFORM_WINDOWS
+ || c == '/'
+#endif
+ ;
+ }
+
+ Catch::StringRef normaliseOpt( Catch::StringRef optName ) {
+ if ( optName[0] == '-'
+#if defined(CATCH_PLATFORM_WINDOWS)
+ || optName[0] == '/'
+#endif
+ ) {
+ return optName.substr( 1, optName.size() );
+ }
+
+ return optName;
+ }
+
+ static size_t find_first_separator(Catch::StringRef sr) {
+ auto is_separator = []( char c ) {
+ return c == ' ' || c == ':' || c == '=';
+ };
+ size_t pos = 0;
+ while (pos < sr.size()) {
+ if (is_separator(sr[pos])) { return pos; }
+ ++pos;
+ }
+
+ return Catch::StringRef::npos;
+ }
+
+} // namespace
+
+namespace Catch {
+ namespace Clara {
+ namespace Detail {
+
+ void TokenStream::loadBuffer() {
+ m_tokenBuffer.clear();
+
+ // Skip any empty strings
+ while ( it != itEnd && it->empty() ) {
+ ++it;
+ }
+
+ if ( it != itEnd ) {
+ StringRef next = *it;
+ if ( isOptPrefix( next[0] ) ) {
+ auto delimiterPos = find_first_separator(next);
+ if ( delimiterPos != StringRef::npos ) {
+ m_tokenBuffer.push_back(
+ { TokenType::Option,
+ next.substr( 0, delimiterPos ) } );
+ m_tokenBuffer.push_back(
+ { TokenType::Argument,
+ next.substr( delimiterPos + 1, next.size() ) } );
+ } else {
+ if ( next[1] != '-' && next.size() > 2 ) {
+ // Combined short args, e.g. "-ab" for "-a -b"
+ for ( size_t i = 1; i < next.size(); ++i ) {
+ m_tokenBuffer.push_back(
+ { TokenType::Option,
+ next.substr( i, 1 ) } );
+ }
+ } else {
+ m_tokenBuffer.push_back(
+ { TokenType::Option, next } );
+ }
+ }
+ } else {
+ m_tokenBuffer.push_back(
+ { TokenType::Argument, next } );
+ }
+ }
+ }
+
+ TokenStream::TokenStream( Args const& args ):
+ TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+
+ TokenStream::TokenStream( Iterator it_, Iterator itEnd_ ):
+ it( it_ ), itEnd( itEnd_ ) {
+ loadBuffer();
+ }
+
+ TokenStream& TokenStream::operator++() {
+ if ( m_tokenBuffer.size() >= 2 ) {
+ m_tokenBuffer.erase( m_tokenBuffer.begin() );
+ } else {
+ if ( it != itEnd )
+ ++it;
+ loadBuffer();
+ }
+ return *this;
+ }
+
+ ParserResult convertInto( std::string const& source,
+ std::string& target ) {
+ target = source;
+ return ParserResult::ok( ParseResultType::Matched );
+ }
+
+ ParserResult convertInto( std::string const& source,
+ bool& target ) {
+ std::string srcLC = toLower( source );
+
+ if ( srcLC == "y" || srcLC == "1" || srcLC == "true" ||
+ srcLC == "yes" || srcLC == "on" ) {
+ target = true;
+ } else if ( srcLC == "n" || srcLC == "0" || srcLC == "false" ||
+ srcLC == "no" || srcLC == "off" ) {
+ target = false;
+ } else {
+ return ParserResult::runtimeError(
+ "Expected a boolean value but did not recognise: '" +
+ source + '\'' );
+ }
+ return ParserResult::ok( ParseResultType::Matched );
+ }
+
+ size_t ParserBase::cardinality() const { return 1; }
+
+ InternalParseResult ParserBase::parse( Args const& args ) const {
+ return parse( static_cast<std::string>(args.exeName()), TokenStream( args ) );
+ }
+
+ ParseState::ParseState( ParseResultType type,
+ TokenStream remainingTokens ):
+ m_type( type ), m_remainingTokens( CATCH_MOVE(remainingTokens) ) {}
+
+ ParserResult BoundFlagRef::setFlag( bool flag ) {
+ m_ref = flag;
+ return ParserResult::ok( ParseResultType::Matched );
+ }
+
+ ResultBase::~ResultBase() = default;
+
+ bool BoundRef::isContainer() const { return false; }
+
+ bool BoundRef::isFlag() const { return false; }
+
+ bool BoundFlagRefBase::isFlag() const { return true; }
+
+} // namespace Detail
+
+ Detail::InternalParseResult Arg::parse(std::string const&,
+ Detail::TokenStream tokens) const {
+ auto validationResult = validate();
+ if (!validationResult)
+ return Detail::InternalParseResult(validationResult);
+
+ auto token = *tokens;
+ if (token.type != Detail::TokenType::Argument)
+ return Detail::InternalParseResult::ok(Detail::ParseState(
+ ParseResultType::NoMatch, CATCH_MOVE(tokens)));
+
+ assert(!m_ref->isFlag());
+ auto valueRef =
+ static_cast<Detail::BoundValueRefBase*>(m_ref.get());
+
+ auto result = valueRef->setValue(static_cast<std::string>(token.token));
+ if ( !result )
+ return Detail::InternalParseResult( result );
+ else
+ return Detail::InternalParseResult::ok(
+ Detail::ParseState( ParseResultType::Matched,
+ CATCH_MOVE( ++tokens ) ) );
+ }
+
+ Opt::Opt(bool& ref) :
+ ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {}
+
+ Detail::HelpColumns Opt::getHelpColumns() const {
+ ReusableStringStream oss;
+ bool first = true;
+ for (auto const& opt : m_optNames) {
+ if (first)
+ first = false;
+ else
+ oss << ", ";
+ oss << opt;
+ }
+ if (!m_hint.empty())
+ oss << " <" << m_hint << '>';
+ return { oss.str(), m_description };
+ }
+
+ bool Opt::isMatch(StringRef optToken) const {
+ auto normalisedToken = normaliseOpt(optToken);
+ for (auto const& name : m_optNames) {
+ if (normaliseOpt(name) == normalisedToken)
+ return true;
+ }
+ return false;
+ }
+
+ Detail::InternalParseResult Opt::parse(std::string const&,
+ Detail::TokenStream tokens) const {
+ auto validationResult = validate();
+ if (!validationResult)
+ return Detail::InternalParseResult(validationResult);
+
+ if (tokens &&
+ tokens->type == Detail::TokenType::Option) {
+ auto const& token = *tokens;
+ if (isMatch(token.token)) {
+ if (m_ref->isFlag()) {
+ auto flagRef =
+ static_cast<Detail::BoundFlagRefBase*>(
+ m_ref.get());
+ auto result = flagRef->setFlag(true);
+ if (!result)
+ return Detail::InternalParseResult(result);
+ if (result.value() ==
+ ParseResultType::ShortCircuitAll)
+ return Detail::InternalParseResult::ok(Detail::ParseState(
+ result.value(), CATCH_MOVE(tokens)));
+ } else {
+ auto valueRef =
+ static_cast<Detail::BoundValueRefBase*>(
+ m_ref.get());
+ ++tokens;
+ if (!tokens)
+ return Detail::InternalParseResult::runtimeError(
+ "Expected argument following " +
+ token.token);
+ auto const& argToken = *tokens;
+ if (argToken.type != Detail::TokenType::Argument)
+ return Detail::InternalParseResult::runtimeError(
+ "Expected argument following " +
+ token.token);
+ const auto result = valueRef->setValue(static_cast<std::string>(argToken.token));
+ if (!result)
+ return Detail::InternalParseResult(result);
+ if (result.value() ==
+ ParseResultType::ShortCircuitAll)
+ return Detail::InternalParseResult::ok(Detail::ParseState(
+ result.value(), CATCH_MOVE(tokens)));
+ }
+ return Detail::InternalParseResult::ok(Detail::ParseState(
+ ParseResultType::Matched, CATCH_MOVE(++tokens)));
+ }
+ }
+ return Detail::InternalParseResult::ok(
+ Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
+ }
+
+ Detail::Result Opt::validate() const {
+ if (m_optNames.empty())
+ return Detail::Result::logicError("No options supplied to Opt");
+ for (auto const& name : m_optNames) {
+ if (name.empty())
+ return Detail::Result::logicError(
+ "Option name cannot be empty");
+#ifdef CATCH_PLATFORM_WINDOWS
+ if (name[0] != '-' && name[0] != '/')
+ return Detail::Result::logicError(
+ "Option name must begin with '-' or '/'");
+#else
+ if (name[0] != '-')
+ return Detail::Result::logicError(
+ "Option name must begin with '-'");
+#endif
+ }
+ return ParserRefImpl::validate();
+ }
+
+ ExeName::ExeName() :
+ m_name(std::make_shared<std::string>("<executable>")) {}
+
+ ExeName::ExeName(std::string& ref) : ExeName() {
+ m_ref = std::make_shared<Detail::BoundValueRef<std::string>>(ref);
+ }
+
+ Detail::InternalParseResult
+ ExeName::parse(std::string const&,
+ Detail::TokenStream tokens) const {
+ return Detail::InternalParseResult::ok(
+ Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
+ }
+
+ ParserResult ExeName::set(std::string const& newName) {
+ auto lastSlash = newName.find_last_of("\\/");
+ auto filename = (lastSlash == std::string::npos)
+ ? newName
+ : newName.substr(lastSlash + 1);
+
+ *m_name = filename;
+ if (m_ref)
+ return m_ref->setValue(filename);
+ else
+ return ParserResult::ok(ParseResultType::Matched);
+ }
+
+
+
+
+ Parser& Parser::operator|=( Parser const& other ) {
+ m_options.insert( m_options.end(),
+ other.m_options.begin(),
+ other.m_options.end() );
+ m_args.insert(
+ m_args.end(), other.m_args.begin(), other.m_args.end() );
+ return *this;
+ }
+
+ std::vector<Detail::HelpColumns> Parser::getHelpColumns() const {
+ std::vector<Detail::HelpColumns> cols;
+ cols.reserve( m_options.size() );
+ for ( auto const& o : m_options ) {
+ cols.push_back(o.getHelpColumns());
+ }
+ return cols;
+ }
+
+ void Parser::writeToStream( std::ostream& os ) const {
+ if ( !m_exeName.name().empty() ) {
+ os << "usage:\n"
+ << " " << m_exeName.name() << ' ';
+ bool required = true, first = true;
+ for ( auto const& arg : m_args ) {
+ if ( first )
+ first = false;
+ else
+ os << ' ';
+ if ( arg.isOptional() && required ) {
+ os << '[';
+ required = false;
+ }
+ os << '<' << arg.hint() << '>';
+ if ( arg.cardinality() == 0 )
+ os << " ... ";
+ }
+ if ( !required )
+ os << ']';
+ if ( !m_options.empty() )
+ os << " options";
+ os << "\n\nwhere options are:\n";
+ }
+
+ auto rows = getHelpColumns();
+ size_t consoleWidth = CATCH_CONFIG_CONSOLE_WIDTH;
+ size_t optWidth = 0;
+ for ( auto const& cols : rows )
+ optWidth = ( std::max )( optWidth, cols.left.size() + 2 );
+
+ optWidth = ( std::min )( optWidth, consoleWidth / 2 );
+
+ for ( auto& cols : rows ) {
+ auto row = TextFlow::Column( CATCH_MOVE(cols.left) )
+ .width( optWidth )
+ .indent( 2 ) +
+ TextFlow::Spacer( 4 ) +
+ TextFlow::Column( static_cast<std::string>(cols.descriptions) )
+ .width( consoleWidth - 7 - optWidth );
+ os << row << '\n';
+ }
+ }
+
+ Detail::Result Parser::validate() const {
+ for ( auto const& opt : m_options ) {
+ auto result = opt.validate();
+ if ( !result )
+ return result;
+ }
+ for ( auto const& arg : m_args ) {
+ auto result = arg.validate();
+ if ( !result )
+ return result;
+ }
+ return Detail::Result::ok();
+ }
+
+ Detail::InternalParseResult
+ Parser::parse( std::string const& exeName,
+ Detail::TokenStream tokens ) const {
+
+ struct ParserInfo {
+ ParserBase const* parser = nullptr;
+ size_t count = 0;
+ };
+ std::vector<ParserInfo> parseInfos;
+ parseInfos.reserve( m_options.size() + m_args.size() );
+ for ( auto const& opt : m_options ) {
+ parseInfos.push_back( { &opt, 0 } );
+ }
+ for ( auto const& arg : m_args ) {
+ parseInfos.push_back( { &arg, 0 } );
+ }
+
+ m_exeName.set( exeName );
+
+ auto result = Detail::InternalParseResult::ok(
+ Detail::ParseState( ParseResultType::NoMatch, CATCH_MOVE(tokens) ) );
+ while ( result.value().remainingTokens() ) {
+ bool tokenParsed = false;
+
+ for ( auto& parseInfo : parseInfos ) {
+ if ( parseInfo.parser->cardinality() == 0 ||
+ parseInfo.count < parseInfo.parser->cardinality() ) {
+ result = parseInfo.parser->parse(
+ exeName, CATCH_MOVE(result).value().remainingTokens() );
+ if ( !result )
+ return result;
+ if ( result.value().type() !=
+ ParseResultType::NoMatch ) {
+ tokenParsed = true;
+ ++parseInfo.count;
+ break;
+ }
+ }
+ }
+
+ if ( result.value().type() == ParseResultType::ShortCircuitAll )
+ return result;
+ if ( !tokenParsed )
+ return Detail::InternalParseResult::runtimeError(
+ "Unrecognised token: " +
+ result.value().remainingTokens()->token );
+ }
+ // !TBD Check missing required options
+ return result;
+ }
+
+ Args::Args(int argc, char const* const* argv) :
+ m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
+
+ Args::Args(std::initializer_list<StringRef> args) :
+ m_exeName(*args.begin()),
+ m_args(args.begin() + 1, args.end()) {}
+
+
+ Help::Help( bool& showHelpFlag ):
+ Opt( [&]( bool flag ) {
+ showHelpFlag = flag;
+ return ParserResult::ok( ParseResultType::ShortCircuitAll );
+ } ) {
+ static_cast<Opt&> ( *this )(
+ "display usage information" )["-?"]["-h"]["--help"]
+ .optional();
+ }
+
+ } // namespace Clara
+} // namespace Catch
+
+
+
+
+#include <fstream>
+#include <string>
+
+namespace Catch {
+
+ Clara::Parser makeCommandLineParser( ConfigData& config ) {
+
+ using namespace Clara;
+
+ auto const setWarning = [&]( std::string const& warning ) {
+ if ( warning == "NoAssertions" ) {
+ config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions);
+ return ParserResult::ok( ParseResultType::Matched );
+ } else if ( warning == "UnmatchedTestSpec" ) {
+ config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::UnmatchedTestSpec);
+ return ParserResult::ok( ParseResultType::Matched );
+ }
+
+ return ParserResult ::runtimeError(
+ "Unrecognised warning option: '" + warning + '\'' );
+ };
+ auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
+ std::ifstream f( filename.c_str() );
+ if( !f.is_open() )
+ return ParserResult::runtimeError( "Unable to load input file: '" + filename + '\'' );
+
+ std::string line;
+ while( std::getline( f, line ) ) {
+ line = trim(line);
+ if( !line.empty() && !startsWith( line, '#' ) ) {
+ if( !startsWith( line, '"' ) )
+ line = '"' + CATCH_MOVE(line) + '"';
+ config.testsOrTags.push_back( line );
+ config.testsOrTags.emplace_back( "," );
+ }
+ }
+ //Remove comma in the end
+ if(!config.testsOrTags.empty())
+ config.testsOrTags.erase( config.testsOrTags.end()-1 );
+
+ return ParserResult::ok( ParseResultType::Matched );
+ };
+ auto const setTestOrder = [&]( std::string const& order ) {
+ if( startsWith( "declared", order ) )
+ config.runOrder = TestRunOrder::Declared;
+ else if( startsWith( "lexical", order ) )
+ config.runOrder = TestRunOrder::LexicographicallySorted;
+ else if( startsWith( "random", order ) )
+ config.runOrder = TestRunOrder::Randomized;
+ else
+ return ParserResult::runtimeError( "Unrecognised ordering: '" + order + '\'' );
+ return ParserResult::ok( ParseResultType::Matched );
+ };
+ auto const setRngSeed = [&]( std::string const& seed ) {
+ if( seed == "time" ) {
+ config.rngSeed = generateRandomSeed(GenerateFrom::Time);
+ return ParserResult::ok(ParseResultType::Matched);
+ } else if (seed == "random-device") {
+ config.rngSeed = generateRandomSeed(GenerateFrom::RandomDevice);
+ return ParserResult::ok(ParseResultType::Matched);
+ }
+
+ // TODO: ideally we should be parsing uint32_t directly
+ // fix this later when we add new parse overload
+ auto parsedSeed = parseUInt( seed, 0 );
+ if ( !parsedSeed ) {
+ return ParserResult::runtimeError( "Could not parse '" + seed + "' as seed" );
+ }
+ config.rngSeed = *parsedSeed;
+ return ParserResult::ok( ParseResultType::Matched );
+ };
+ auto const setDefaultColourMode = [&]( std::string const& colourMode ) {
+ Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
+ if ( !maybeMode ) {
+ return ParserResult::runtimeError(
+ "colour mode must be one of: default, ansi, win32, "
+ "or none. '" +
+ colourMode + "' is not recognised" );
+ }
+ auto mode = *maybeMode;
+ if ( !isColourImplAvailable( mode ) ) {
+ return ParserResult::runtimeError(
+ "colour mode '" + colourMode +
+ "' is not supported in this binary" );
+ }
+ config.defaultColourMode = mode;
+ return ParserResult::ok( ParseResultType::Matched );
+ };
+ auto const setWaitForKeypress = [&]( std::string const& keypress ) {
+ auto keypressLc = toLower( keypress );
+ if (keypressLc == "never")
+ config.waitForKeypress = WaitForKeypress::Never;
+ else if( keypressLc == "start" )
+ config.waitForKeypress = WaitForKeypress::BeforeStart;
+ else if( keypressLc == "exit" )
+ config.waitForKeypress = WaitForKeypress::BeforeExit;
+ else if( keypressLc == "both" )
+ config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+ else
+ return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
+ return ParserResult::ok( ParseResultType::Matched );
+ };
+ auto const setVerbosity = [&]( std::string const& verbosity ) {
+ auto lcVerbosity = toLower( verbosity );
+ if( lcVerbosity == "quiet" )
+ config.verbosity = Verbosity::Quiet;
+ else if( lcVerbosity == "normal" )
+ config.verbosity = Verbosity::Normal;
+ else if( lcVerbosity == "high" )
+ config.verbosity = Verbosity::High;
+ else
+ return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + '\'' );
+ return ParserResult::ok( ParseResultType::Matched );
+ };
+ auto const setReporter = [&]( std::string const& userReporterSpec ) {
+ if ( userReporterSpec.empty() ) {
+ return ParserResult::runtimeError( "Received empty reporter spec." );
+ }
+
+ Optional<ReporterSpec> parsed =
+ parseReporterSpec( userReporterSpec );
+ if ( !parsed ) {
+ return ParserResult::runtimeError(
+ "Could not parse reporter spec '" + userReporterSpec +
+ "'" );
+ }
+
+ auto const& reporterSpec = *parsed;
+
+ auto const& factories =
+ getRegistryHub().getReporterRegistry().getFactories();
+ auto result = factories.find( reporterSpec.name() );
+
+ if ( result == factories.end() ) {
+ return ParserResult::runtimeError(
+ "Unrecognized reporter, '" + reporterSpec.name() +
+ "'. Check available with --list-reporters" );
+ }
+
+
+ const bool hadOutputFile = reporterSpec.outputFile().some();
+ config.reporterSpecifications.push_back( CATCH_MOVE( *parsed ) );
+ // It would be enough to check this only once at the very end, but
+ // there is not a place where we could call this check, so do it
+ // every time it could fail. For valid inputs, this is still called
+ // at most once.
+ if (!hadOutputFile) {
+ int n_reporters_without_file = 0;
+ for (auto const& spec : config.reporterSpecifications) {
+ if (spec.outputFile().none()) {
+ n_reporters_without_file++;
+ }
+ }
+ if (n_reporters_without_file > 1) {
+ return ParserResult::runtimeError( "Only one reporter may have unspecified output file." );
+ }
+ }
+
+ return ParserResult::ok( ParseResultType::Matched );
+ };
+ auto const setShardCount = [&]( std::string const& shardCount ) {
+ auto parsedCount = parseUInt( shardCount );
+ if ( !parsedCount ) {
+ return ParserResult::runtimeError(
+ "Could not parse '" + shardCount + "' as shard count" );
+ }
+ if ( *parsedCount == 0 ) {
+ return ParserResult::runtimeError(
+ "Shard count must be positive" );
+ }
+ config.shardCount = *parsedCount;
+ return ParserResult::ok( ParseResultType::Matched );
+ };
+
+ auto const setShardIndex = [&](std::string const& shardIndex) {
+ auto parsedIndex = parseUInt( shardIndex );
+ if ( !parsedIndex ) {
+ return ParserResult::runtimeError(
+ "Could not parse '" + shardIndex + "' as shard index" );
+ }
+ config.shardIndex = *parsedIndex;
+ return ParserResult::ok( ParseResultType::Matched );
+ };
+
+ auto cli
+ = ExeName( config.processName )
+ | Help( config.showHelp )
+ | Opt( config.showSuccessfulTests )
+ ["-s"]["--success"]
+ ( "include successful tests in output" )
+ | Opt( config.shouldDebugBreak )
+ ["-b"]["--break"]
+ ( "break into debugger on failure" )
+ | Opt( config.noThrow )
+ ["-e"]["--nothrow"]
+ ( "skip exception tests" )
+ | Opt( config.showInvisibles )
+ ["-i"]["--invisibles"]
+ ( "show invisibles (tabs, newlines)" )
+ | Opt( config.defaultOutputFilename, "filename" )
+ ["-o"]["--out"]
+ ( "default output filename" )
+ | Opt( accept_many, setReporter, "name[::key=value]*" )
+ ["-r"]["--reporter"]
+ ( "reporter to use (defaults to console)" )
+ | Opt( config.name, "name" )
+ ["-n"]["--name"]
+ ( "suite name" )
+ | Opt( [&]( bool ){ config.abortAfter = 1; } )
+ ["-a"]["--abort"]
+ ( "abort at first failure" )
+ | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
+ ["-x"]["--abortx"]
+ ( "abort after x failures" )
+ | Opt( accept_many, setWarning, "warning name" )
+ ["-w"]["--warn"]
+ ( "enable warnings" )
+ | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
+ ["-d"]["--durations"]
+ ( "show test durations" )
+ | Opt( config.minDuration, "seconds" )
+ ["-D"]["--min-duration"]
+ ( "show test durations for tests taking at least the given number of seconds" )
+ | Opt( loadTestNamesFromFile, "filename" )
+ ["-f"]["--input-file"]
+ ( "load test names to run from a file" )
+ | Opt( config.filenamesAsTags )
+ ["-#"]["--filenames-as-tags"]
+ ( "adds a tag for the filename" )
+ | Opt( config.sectionsToRun, "section name" )
+ ["-c"]["--section"]
+ ( "specify section to run" )
+ | Opt( setVerbosity, "quiet|normal|high" )
+ ["-v"]["--verbosity"]
+ ( "set output verbosity" )
+ | Opt( config.listTests )
+ ["--list-tests"]
+ ( "list all/matching test cases" )
+ | Opt( config.listTags )
+ ["--list-tags"]
+ ( "list all/matching tags" )
+ | Opt( config.listReporters )
+ ["--list-reporters"]
+ ( "list all available reporters" )
+ | Opt( config.listListeners )
+ ["--list-listeners"]
+ ( "list all listeners" )
+ | Opt( setTestOrder, "decl|lex|rand" )
+ ["--order"]
+ ( "test case order (defaults to decl)" )
+ | Opt( setRngSeed, "'time'|'random-device'|number" )
+ ["--rng-seed"]
+ ( "set a specific seed for random numbers" )
+ | Opt( setDefaultColourMode, "ansi|win32|none|default" )
+ ["--colour-mode"]
+ ( "what color mode should be used as default" )
+ | Opt( config.libIdentify )
+ ["--libidentify"]
+ ( "report name and version according to libidentify standard" )
+ | Opt( setWaitForKeypress, "never|start|exit|both" )
+ ["--wait-for-keypress"]
+ ( "waits for a keypress before exiting" )
+ | Opt( config.skipBenchmarks)
+ ["--skip-benchmarks"]
+ ( "disable running benchmarks")
+ | Opt( config.benchmarkSamples, "samples" )
+ ["--benchmark-samples"]
+ ( "number of samples to collect (default: 100)" )
+ | Opt( config.benchmarkResamples, "resamples" )
+ ["--benchmark-resamples"]
+ ( "number of resamples for the bootstrap (default: 100000)" )
+ | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
+ ["--benchmark-confidence-interval"]
+ ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
+ | Opt( config.benchmarkNoAnalysis )
+ ["--benchmark-no-analysis"]
+ ( "perform only measurements; do not perform any analysis" )
+ | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
+ ["--benchmark-warmup-time"]
+ ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
+ | Opt( setShardCount, "shard count" )
+ ["--shard-count"]
+ ( "split the tests to execute into this many groups" )
+ | Opt( setShardIndex, "shard index" )
+ ["--shard-index"]
+ ( "index of the group of tests to execute (see --shard-count)" )
+ | Opt( config.allowZeroTests )
+ ["--allow-running-no-tests"]
+ ( "Treat 'No tests run' as a success" )
+ | Arg( config.testsOrTags, "test name|pattern|tags" )
+ ( "which test or tests to use" );
+
+ return cli;
+ }
+
+} // end namespace Catch
+
+
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+
+
+#include <cassert>
+#include <ostream>
+#include <utility>
+
+namespace Catch {
+
+ ColourImpl::~ColourImpl() = default;
+
+ ColourImpl::ColourGuard ColourImpl::guardColour( Colour::Code colourCode ) {
+ return ColourGuard(colourCode, this );
+ }
+
+ void ColourImpl::ColourGuard::engageImpl( std::ostream& stream ) {
+ assert( &stream == &m_colourImpl->m_stream->stream() &&
+ "Engaging colour guard for different stream than used by the "
+ "parent colour implementation" );
+ static_cast<void>( stream );
+
+ m_engaged = true;
+ m_colourImpl->use( m_code );
+ }
+
+ ColourImpl::ColourGuard::ColourGuard( Colour::Code code,
+ ColourImpl const* colour ):
+ m_colourImpl( colour ), m_code( code ) {
+ }
+ ColourImpl::ColourGuard::ColourGuard( ColourGuard&& rhs ) noexcept:
+ m_colourImpl( rhs.m_colourImpl ),
+ m_code( rhs.m_code ),
+ m_engaged( rhs.m_engaged ) {
+ rhs.m_engaged = false;
+ }
+ ColourImpl::ColourGuard&
+ ColourImpl::ColourGuard::operator=( ColourGuard&& rhs ) noexcept {
+ using std::swap;
+ swap( m_colourImpl, rhs.m_colourImpl );
+ swap( m_code, rhs.m_code );
+ swap( m_engaged, rhs.m_engaged );
+
+ return *this;
+ }
+ ColourImpl::ColourGuard::~ColourGuard() {
+ if ( m_engaged ) {
+ m_colourImpl->use( Colour::None );
+ }
+ }
+
+ ColourImpl::ColourGuard&
+ ColourImpl::ColourGuard::engage( std::ostream& stream ) & {
+ engageImpl( stream );
+ return *this;
+ }
+
+ ColourImpl::ColourGuard&&
+ ColourImpl::ColourGuard::engage( std::ostream& stream ) && {
+ engageImpl( stream );
+ return CATCH_MOVE(*this);
+ }
+
+ namespace {
+ //! A do-nothing implementation of colour, used as fallback for unknown
+ //! platforms, and when the user asks to deactivate all colours.
+ class NoColourImpl final : public ColourImpl {
+ public:
+ NoColourImpl( IStream* stream ): ColourImpl( stream ) {}
+
+ private:
+ void use( Colour::Code ) const override {}
+ };
+ } // namespace
+
+
+} // namespace Catch
+
+
+#if defined ( CATCH_CONFIG_COLOUR_WIN32 ) /////////////////////////////////////////
+
+namespace Catch {
+namespace {
+
+ class Win32ColourImpl final : public ColourImpl {
+ public:
+ Win32ColourImpl(IStream* stream):
+ ColourImpl(stream) {
+ CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+ GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ),
+ &csbiInfo );
+ originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
+ originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
+ }
+
+ static bool useImplementationForStream(IStream const& stream) {
+ // Win32 text colour APIs can only be used on console streams
+ // We cannot check that the output hasn't been redirected,
+ // so we just check that the original stream is console stream.
+ return stream.isConsole();
+ }
+
+ private:
+ void use( Colour::Code _colourCode ) const override {
+ switch( _colourCode ) {
+ case Colour::None: return setTextAttribute( originalForegroundAttributes );
+ case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+ case Colour::Red: return setTextAttribute( FOREGROUND_RED );
+ case Colour::Green: return setTextAttribute( FOREGROUND_GREEN );
+ case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE );
+ case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+ case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+ case Colour::Grey: return setTextAttribute( 0 );
+
+ case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY );
+ case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+ case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+ case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+ case Colour::BrightYellow: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
+
+ case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+
+ default:
+ CATCH_ERROR( "Unknown colour requested" );
+ }
+ }
+
+ void setTextAttribute( WORD _textAttribute ) const {
+ SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),
+ _textAttribute |
+ originalBackgroundAttributes );
+ }
+ WORD originalForegroundAttributes;
+ WORD originalBackgroundAttributes;
+ };
+
+} // end anon namespace
+} // end namespace Catch
+
+#endif // Windows/ ANSI/ None
+
+
+#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )
+# define CATCH_INTERNAL_HAS_ISATTY
+# include <unistd.h>
+#endif
+
+namespace Catch {
+namespace {
+
+ class ANSIColourImpl final : public ColourImpl {
+ public:
+ ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}
+
+ static bool useImplementationForStream(IStream const& stream) {
+ // This is kinda messy due to trying to support a bunch of
+ // different platforms at once.
+ // The basic idea is that if we are asked to do autodetection (as
+ // opposed to being told to use posixy colours outright), then we
+ // only want to use the colours if we are writing to console.
+ // However, console might be redirected, so we make an attempt at
+ // checking for that on platforms where we know how to do that.
+ bool useColour = stream.isConsole();
+#if defined( CATCH_INTERNAL_HAS_ISATTY ) && \
+ !( defined( __DJGPP__ ) && defined( __STRICT_ANSI__ ) )
+ ErrnoGuard _; // for isatty
+ useColour = useColour && isatty( STDOUT_FILENO );
+# endif
+# if defined( CATCH_PLATFORM_MAC ) || defined( CATCH_PLATFORM_IPHONE )
+ useColour = useColour && !isDebuggerActive();
+# endif
+
+ return useColour;
+ }
+
+ private:
+ void use( Colour::Code _colourCode ) const override {
+ auto setColour = [&out =
+ m_stream->stream()]( char const* escapeCode ) {
+ // The escape sequence must be flushed to console, otherwise
+ // if stdin and stderr are intermixed, we'd get accidentally
+ // coloured output.
+ out << '\033' << escapeCode << std::flush;
+ };
+ switch( _colourCode ) {
+ case Colour::None:
+ case Colour::White: return setColour( "[0m" );
+ case Colour::Red: return setColour( "[0;31m" );
+ case Colour::Green: return setColour( "[0;32m" );
+ case Colour::Blue: return setColour( "[0;34m" );
+ case Colour::Cyan: return setColour( "[0;36m" );
+ case Colour::Yellow: return setColour( "[0;33m" );
+ case Colour::Grey: return setColour( "[1;30m" );
+
+ case Colour::LightGrey: return setColour( "[0;37m" );
+ case Colour::BrightRed: return setColour( "[1;31m" );
+ case Colour::BrightGreen: return setColour( "[1;32m" );
+ case Colour::BrightWhite: return setColour( "[1;37m" );
+ case Colour::BrightYellow: return setColour( "[1;33m" );
+
+ case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+ default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
+ }
+ }
+ };
+
+} // end anon namespace
+} // end namespace Catch
+
+namespace Catch {
+
+ Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
+ IStream* stream ) {
+#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+ if ( colourSelection == ColourMode::Win32 ) {
+ return Detail::make_unique<Win32ColourImpl>( stream );
+ }
+#endif
+ if ( colourSelection == ColourMode::ANSI ) {
+ return Detail::make_unique<ANSIColourImpl>( stream );
+ }
+ if ( colourSelection == ColourMode::None ) {
+ return Detail::make_unique<NoColourImpl>( stream );
+ }
+
+ if ( colourSelection == ColourMode::PlatformDefault) {
+#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+ if ( Win32ColourImpl::useImplementationForStream( *stream ) ) {
+ return Detail::make_unique<Win32ColourImpl>( stream );
+ }
+#endif
+ if ( ANSIColourImpl::useImplementationForStream( *stream ) ) {
+ return Detail::make_unique<ANSIColourImpl>( stream );
+ }
+ return Detail::make_unique<NoColourImpl>( stream );
+ }
+
+ CATCH_ERROR( "Could not create colour impl for selection " << static_cast<int>(colourSelection) );
+ }
+
+ bool isColourImplAvailable( ColourMode colourSelection ) {
+ switch ( colourSelection ) {
+#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+ case ColourMode::Win32:
+#endif
+ case ColourMode::ANSI:
+ case ColourMode::None:
+ case ColourMode::PlatformDefault:
+ return true;
+ default:
+ return false;
+ }
+ }
+
+
+} // end namespace Catch
+
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+
+
+
+
+namespace Catch {
+
+ Context* Context::currentContext = nullptr;
+
+ void cleanUpContext() {
+ delete Context::currentContext;
+ Context::currentContext = nullptr;
+ }
+ void Context::createContext() {
+ currentContext = new Context();
+ }
+
+ Context& getCurrentMutableContext() {
+ if ( !Context::currentContext ) { Context::createContext(); }
+ // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+ return *Context::currentContext;
+ }
+
+ void Context::setResultCapture( IResultCapture* resultCapture ) {
+ m_resultCapture = resultCapture;
+ }
+
+ void Context::setConfig( IConfig const* config ) { m_config = config; }
+
+ SimplePcg32& sharedRng() {
+ static SimplePcg32 s_rng;
+ return s_rng;
+ }
+
+}
+
+
+
+
+
+#include <ostream>
+
+#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#include <android/log.h>
+
+ namespace Catch {
+ void writeToDebugConsole( std::string const& text ) {
+ __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
+ }
+ }
+
+#elif defined(CATCH_PLATFORM_WINDOWS)
+
+ namespace Catch {
+ void writeToDebugConsole( std::string const& text ) {
+ ::OutputDebugStringA( text.c_str() );
+ }
+ }
+
+#else
+
+ namespace Catch {
+ void writeToDebugConsole( std::string const& text ) {
+ // !TBD: Need a version for Mac/ XCode and other IDEs
+ Catch::cout() << text;
+ }
+ }
+
+#endif // Platform
+
+
+
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+
+# include <cassert>
+# include <sys/types.h>
+# include <unistd.h>
+# include <cstddef>
+# include <ostream>
+
+#ifdef __apple_build_version__
+ // These headers will only compile with AppleClang (XCode)
+ // For other compilers (Clang, GCC, ... ) we need to exclude them
+# include <sys/sysctl.h>
+#endif
+
+ namespace Catch {
+ #ifdef __apple_build_version__
+ // The following function is taken directly from the following technical note:
+ // https://developer.apple.com/library/archive/qa/qa1361/_index.html
+
+ // Returns true if the current process is being debugged (either
+ // running under the debugger or has a debugger attached post facto).
+ bool isDebuggerActive(){
+ int mib[4];
+ struct kinfo_proc info;
+ std::size_t size;
+
+ // Initialize the flags so that, if sysctl fails for some bizarre
+ // reason, we get a predictable result.
+
+ info.kp_proc.p_flag = 0;
+
+ // Initialize mib, which tells sysctl the info we want, in this case
+ // we're looking for information about a specific process ID.
+
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_PID;
+ mib[3] = getpid();
+
+ // Call sysctl.
+
+ size = sizeof(info);
+ if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
+ Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n\n" << std::flush;
+ return false;
+ }
+
+ // We're being debugged if the P_TRACED flag is set.
+
+ return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+ }
+ #else
+ bool isDebuggerActive() {
+ // We need to find another way to determine this for non-appleclang compilers on macOS
+ return false;
+ }
+ #endif
+ } // namespace Catch
+
+#elif defined(CATCH_PLATFORM_LINUX)
+ #include <fstream>
+ #include <string>
+
+ namespace Catch{
+ // The standard POSIX way of detecting a debugger is to attempt to
+ // ptrace() the process, but this needs to be done from a child and not
+ // this process itself to still allow attaching to this process later
+ // if wanted, so is rather heavy. Under Linux we have the PID of the
+ // "debugger" (which doesn't need to be gdb, of course, it could also
+ // be strace, for example) in /proc/$PID/status, so just get it from
+ // there instead.
+ bool isDebuggerActive(){
+ // Libstdc++ has a bug, where std::ifstream sets errno to 0
+ // This way our users can properly assert over errno values
+ ErrnoGuard guard;
+ std::ifstream in("/proc/self/status");
+ for( std::string line; std::getline(in, line); ) {
+ static const int PREFIX_LEN = 11;
+ if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
+ // We're traced if the PID is not 0 and no other PID starts
+ // with 0 digit, so it's enough to check for just a single
+ // character.
+ return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+ }
+ }
+
+ return false;
+ }
+ } // namespace Catch
+#elif defined(_MSC_VER)
+ extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+ namespace Catch {
+ bool isDebuggerActive() {
+ return IsDebuggerPresent() != 0;
+ }
+ }
+#elif defined(__MINGW32__)
+ extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+ namespace Catch {
+ bool isDebuggerActive() {
+ return IsDebuggerPresent() != 0;
+ }
+ }
+#else
+ namespace Catch {
+ bool isDebuggerActive() { return false; }
+ }
+#endif // Platform
+
+
+
+
+namespace Catch {
+
+ void ITransientExpression::streamReconstructedExpression(
+ std::ostream& os ) const {
+ // We can't make this function pure virtual to keep ITransientExpression
+ // constexpr, so we write error message instead
+ os << "Some class derived from ITransientExpression without overriding streamReconstructedExpression";
+ }
+
+ void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
+ if( lhs.size() + rhs.size() < 40 &&
+ lhs.find('\n') == std::string::npos &&
+ rhs.find('\n') == std::string::npos )
+ os << lhs << ' ' << op << ' ' << rhs;
+ else
+ os << lhs << '\n' << op << '\n' << rhs;
+ }
+}
+
+
+
+#include <stdexcept>
+
+
+namespace Catch {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+ [[noreturn]]
+ void throw_exception(std::exception const& e) {
+ Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
+ << "The message was: " << e.what() << '\n';
+ std::terminate();
+ }
+#endif
+
+ [[noreturn]]
+ void throw_logic_error(std::string const& msg) {
+ throw_exception(std::logic_error(msg));
+ }
+
+ [[noreturn]]
+ void throw_domain_error(std::string const& msg) {
+ throw_exception(std::domain_error(msg));
+ }
+
+ [[noreturn]]
+ void throw_runtime_error(std::string const& msg) {
+ throw_exception(std::runtime_error(msg));
+ }
+
+
+
+} // namespace Catch;
+
+
+
+#include <cassert>
+
+namespace Catch {
+
+ IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() = default;
+
+ namespace Detail {
+
+ namespace {
+ // Extracts the actual name part of an enum instance
+ // In other words, it returns the Blue part of Bikeshed::Colour::Blue
+ StringRef extractInstanceName(StringRef enumInstance) {
+ // Find last occurrence of ":"
+ size_t name_start = enumInstance.size();
+ while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+ --name_start;
+ }
+ return enumInstance.substr(name_start, enumInstance.size() - name_start);
+ }
+ }
+
+ std::vector<StringRef> parseEnums( StringRef enums ) {
+ auto enumValues = splitStringRef( enums, ',' );
+ std::vector<StringRef> parsed;
+ parsed.reserve( enumValues.size() );
+ for( auto const& enumValue : enumValues ) {
+ parsed.push_back(trim(extractInstanceName(enumValue)));
+ }
+ return parsed;
+ }
+
+ EnumInfo::~EnumInfo() = default;
+
+ StringRef EnumInfo::lookup( int value ) const {
+ for( auto const& valueToName : m_values ) {
+ if( valueToName.first == value )
+ return valueToName.second;
+ }
+ return "{** unexpected enum value **}"_sr;
+ }
+
+ Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+ auto enumInfo = Catch::Detail::make_unique<EnumInfo>();
+ enumInfo->m_name = enumName;
+ enumInfo->m_values.reserve( values.size() );
+
+ const auto valueNames = Catch::Detail::parseEnums( allValueNames );
+ assert( valueNames.size() == values.size() );
+ std::size_t i = 0;
+ for( auto value : values )
+ enumInfo->m_values.emplace_back(value, valueNames[i++]);
+
+ return enumInfo;
+ }
+
+ EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+ m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
+ return *m_enumInfos.back();
+ }
+
+ } // Detail
+} // Catch
+
+
+
+
+
+#include <cerrno>
+
+namespace Catch {
+ ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
+ ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
+}
+
+
+
+#include <exception>
+
+namespace Catch {
+
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+ namespace {
+ static std::string tryTranslators(
+ std::vector<
+ Detail::unique_ptr<IExceptionTranslator const>> const& translators ) {
+ if ( translators.empty() ) {
+ std::rethrow_exception( std::current_exception() );
+ } else {
+ return translators[0]->translate( translators.begin() + 1,
+ translators.end() );
+ }
+ }
+
+ }
+#endif //!defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+
+ ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() = default;
+
+ void ExceptionTranslatorRegistry::registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) {
+ m_translators.push_back( CATCH_MOVE( translator ) );
+ }
+
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+ std::string ExceptionTranslatorRegistry::translateActiveException() const {
+ // Compiling a mixed mode project with MSVC means that CLR
+ // exceptions will be caught in (...) as well. However, these do
+ // do not fill-in std::current_exception and thus lead to crash
+ // when attempting rethrow.
+ // /EHa switch also causes structured exceptions to be caught
+ // here, but they fill-in current_exception properly, so
+ // at worst the output should be a little weird, instead of
+ // causing a crash.
+ if ( std::current_exception() == nullptr ) {
+ return "Non C++ exception. Possibly a CLR exception.";
+ }
+
+ // First we try user-registered translators. If none of them can
+ // handle the exception, it will be rethrown handled by our defaults.
+ try {
+ return tryTranslators(m_translators);
+ }
+ // To avoid having to handle TFE explicitly everywhere, we just
+ // rethrow it so that it goes back up the caller.
+ catch( TestFailureException& ) {
+ std::rethrow_exception(std::current_exception());
+ }
+ catch( TestSkipException& ) {
+ std::rethrow_exception(std::current_exception());
+ }
+ catch( std::exception const& ex ) {
+ return ex.what();
+ }
+ catch( std::string const& msg ) {
+ return msg;
+ }
+ catch( const char* msg ) {
+ return msg;
+ }
+ catch(...) {
+ return "Unknown exception";
+ }
+ }
+
+#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+ std::string ExceptionTranslatorRegistry::translateActiveException() const {
+ CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+ }
+#endif
+
+}
+
+
+
+/** \file
+ * This file provides platform specific implementations of FatalConditionHandler
+ *
+ * This means that there is a lot of conditional compilation, and platform
+ * specific code. Currently, Catch2 supports a dummy handler (if no
+ * handler is desired), and 2 platform specific handlers:
+ * * Windows' SEH
+ * * POSIX signals
+ *
+ * Consequently, various pieces of code below are compiled if either of
+ * the platform specific handlers is enabled, or if none of them are
+ * enabled. It is assumed that both cannot be enabled at the same time,
+ * and doing so should cause a compilation error.
+ *
+ * If another platform specific handler is added, the compile guards
+ * below will need to be updated taking these assumptions into account.
+ */
+
+
+
+#include <algorithm>
+
+#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace Catch {
+
+ // If neither SEH nor signal handling is required, the handler impls
+ // do not have to do anything, and can be empty.
+ void FatalConditionHandler::engage_platform() {}
+ void FatalConditionHandler::disengage_platform() noexcept {}
+ FatalConditionHandler::FatalConditionHandler() = default;
+ FatalConditionHandler::~FatalConditionHandler() = default;
+
+} // end namespace Catch
+
+#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )
+#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"
+#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace {
+ //! Signals fatal error message to the run context
+ void reportFatal( char const * const message ) {
+ Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
+ }
+
+ //! Minimal size Catch2 needs for its own fatal error handling.
+ //! Picked empirically, so it might not be sufficient on all
+ //! platforms, and for all configurations.
+ constexpr std::size_t minStackSizeForErrors = 32 * 1024;
+} // end unnamed namespace
+
+#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
+
+namespace Catch {
+
+ struct SignalDefs { DWORD id; const char* name; };
+
+ // There is no 1-1 mapping between signals and windows exceptions.
+ // Windows can easily distinguish between SO and SigSegV,
+ // but SigInt, SigTerm, etc are handled differently.
+ static SignalDefs signalDefs[] = {
+ { EXCEPTION_ILLEGAL_INSTRUCTION, "SIGILL - Illegal instruction signal" },
+ { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
+ { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
+ { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
+ };
+
+ static LONG CALLBACK topLevelExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) {
+ for (auto const& def : signalDefs) {
+ if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
+ reportFatal(def.name);
+ }
+ }
+ // If its not an exception we care about, pass it along.
+ // This stops us from eating debugger breaks etc.
+ return EXCEPTION_CONTINUE_SEARCH;
+ }
+
+ // Since we do not support multiple instantiations, we put these
+ // into global variables and rely on cleaning them up in outlined
+ // constructors/destructors
+ static LPTOP_LEVEL_EXCEPTION_FILTER previousTopLevelExceptionFilter = nullptr;
+
+
+ // For MSVC, we reserve part of the stack memory for handling
+ // memory overflow structured exception.
+ FatalConditionHandler::FatalConditionHandler() {
+ ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors);
+ if (!SetThreadStackGuarantee(&guaranteeSize)) {
+ // We do not want to fully error out, because needing
+ // the stack reserve should be rare enough anyway.
+ Catch::cerr()
+ << "Failed to reserve piece of stack."
+ << " Stack overflows will not be reported successfully.";
+ }
+ }
+
+ // We do not attempt to unset the stack guarantee, because
+ // Windows does not support lowering the stack size guarantee.
+ FatalConditionHandler::~FatalConditionHandler() = default;
+
+
+ void FatalConditionHandler::engage_platform() {
+ // Register as a the top level exception filter.
+ previousTopLevelExceptionFilter = SetUnhandledExceptionFilter(topLevelExceptionFilter);
+ }
+
+ void FatalConditionHandler::disengage_platform() noexcept {
+ if (SetUnhandledExceptionFilter(previousTopLevelExceptionFilter) != topLevelExceptionFilter) {
+ Catch::cerr()
+ << "Unexpected SEH unhandled exception filter on disengage."
+ << " The filter was restored, but might be rolled back unexpectedly.";
+ }
+ previousTopLevelExceptionFilter = nullptr;
+ }
+
+} // end namespace Catch
+
+#endif // CATCH_CONFIG_WINDOWS_SEH
+
+#if defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+#include <signal.h>
+
+namespace Catch {
+
+ struct SignalDefs {
+ int id;
+ const char* name;
+ };
+
+ static SignalDefs signalDefs[] = {
+ { SIGINT, "SIGINT - Terminal interrupt signal" },
+ { SIGILL, "SIGILL - Illegal instruction signal" },
+ { SIGFPE, "SIGFPE - Floating point error signal" },
+ { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+ { SIGTERM, "SIGTERM - Termination request signal" },
+ { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+ };
+
+// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
+// which is zero initialization, but not explicit. We want to avoid
+// that.
+#if defined(__GNUC__)
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+ static char* altStackMem = nullptr;
+ static std::size_t altStackSize = 0;
+ static stack_t oldSigStack{};
+ static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};
+
+ static void restorePreviousSignalHandlers() noexcept {
+ // We set signal handlers back to the previous ones. Hopefully
+ // nobody overwrote them in the meantime, and doesn't expect
+ // their signal handlers to live past ours given that they
+ // installed them after ours..
+ for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+ sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
+ }
+ // Return the old stack
+ sigaltstack(&oldSigStack, nullptr);
+ }
+
+ static void handleSignal( int sig ) {
+ char const * name = "<unknown signal>";
+ for (auto const& def : signalDefs) {
+ if (sig == def.id) {
+ name = def.name;
+ break;
+ }
+ }
+ // We need to restore previous signal handlers and let them do
+ // their thing, so that the users can have the debugger break
+ // when a signal is raised, and so on.
+ restorePreviousSignalHandlers();
+ reportFatal( name );
+ raise( sig );
+ }
+
+ FatalConditionHandler::FatalConditionHandler() {
+ assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
+ if (altStackSize == 0) {
+ altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
+ }
+ altStackMem = new char[altStackSize]();
+ }
+
+ FatalConditionHandler::~FatalConditionHandler() {
+ delete[] altStackMem;
+ // We signal that another instance can be constructed by zeroing
+ // out the pointer.
+ altStackMem = nullptr;
+ }
+
+ void FatalConditionHandler::engage_platform() {
+ stack_t sigStack;
+ sigStack.ss_sp = altStackMem;
+ sigStack.ss_size = altStackSize;
+ sigStack.ss_flags = 0;
+ sigaltstack(&sigStack, &oldSigStack);
+ struct sigaction sa = { };
+
+ sa.sa_handler = handleSignal;
+ sa.sa_flags = SA_ONSTACK;
+ for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
+ sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+ }
+ }
+
+#if defined(__GNUC__)
+# pragma GCC diagnostic pop
+#endif
+
+
+ void FatalConditionHandler::disengage_platform() noexcept {
+ restorePreviousSignalHandlers();
+ }
+
+} // end namespace Catch
+
+#endif // CATCH_CONFIG_POSIX_SIGNALS
+
+
+
+
+#include <cstring>
+
+namespace Catch {
+ namespace Detail {
+
+ uint32_t convertToBits(float f) {
+ static_assert(sizeof(float) == sizeof(uint32_t), "Important ULP matcher assumption violated");
+ uint32_t i;
+ std::memcpy(&i, &f, sizeof(f));
+ return i;
+ }
+
+ uint64_t convertToBits(double d) {
+ static_assert(sizeof(double) == sizeof(uint64_t), "Important ULP matcher assumption violated");
+ uint64_t i;
+ std::memcpy(&i, &d, sizeof(d));
+ return i;
+ }
+
+#if defined( __GNUC__ ) || defined( __clang__ )
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wfloat-equal"
+#endif
+ bool directCompare( float lhs, float rhs ) { return lhs == rhs; }
+ bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
+#if defined( __GNUC__ ) || defined( __clang__ )
+# pragma GCC diagnostic pop
+#endif
+
+
+ } // end namespace Detail
+} // end namespace Catch
+
+
+
+
+
+
+#include <cstdlib>
+
+namespace Catch {
+ namespace Detail {
+
+#if !defined (CATCH_CONFIG_GETENV)
+ char const* getEnv( char const* ) { return nullptr; }
+#else
+
+ char const* getEnv( char const* varName ) {
+# if defined( _MSC_VER )
+# pragma warning( push )
+# pragma warning( disable : 4996 ) // use getenv_s instead of getenv
+# endif
+
+ return std::getenv( varName );
+
+# if defined( _MSC_VER )
+# pragma warning( pop )
+# endif
+ }
+#endif
+} // namespace Detail
+} // namespace Catch
+
+
+
+
+#include <cstdio>
+#include <fstream>
+#include <sstream>
+#include <vector>
+
+namespace Catch {
+
+ Catch::IStream::~IStream() = default;
+
+namespace Detail {
+ namespace {
+ template<typename WriterF, std::size_t bufferSize=256>
+ class StreamBufImpl final : public std::streambuf {
+ char data[bufferSize];
+ WriterF m_writer;
+
+ public:
+ StreamBufImpl() {
+ setp( data, data + sizeof(data) );
+ }
+
+ ~StreamBufImpl() noexcept override {
+ StreamBufImpl::sync();
+ }
+
+ private:
+ int overflow( int c ) override {
+ sync();
+
+ if( c != EOF ) {
+ if( pbase() == epptr() )
+ m_writer( std::string( 1, static_cast<char>( c ) ) );
+ else
+ sputc( static_cast<char>( c ) );
+ }
+ return 0;
+ }
+
+ int sync() override {
+ if( pbase() != pptr() ) {
+ m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+ setp( pbase(), epptr() );
+ }
+ return 0;
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+
+ struct OutputDebugWriter {
+
+ void operator()( std::string const& str ) {
+ if ( !str.empty() ) {
+ writeToDebugConsole( str );
+ }
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+
+ class FileStream final : public IStream {
+ std::ofstream m_ofs;
+ public:
+ FileStream( std::string const& filename ) {
+ m_ofs.open( filename.c_str() );
+ CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' );
+ m_ofs << std::unitbuf;
+ }
+ public: // IStream
+ std::ostream& stream() override {
+ return m_ofs;
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+
+ class CoutStream final : public IStream {
+ std::ostream m_os;
+ public:
+ // Store the streambuf from cout up-front because
+ // cout may get redirected when running tests
+ CoutStream() : m_os( Catch::cout().rdbuf() ) {}
+
+ public: // IStream
+ std::ostream& stream() override { return m_os; }
+ bool isConsole() const override { return true; }
+ };
+
+ class CerrStream : public IStream {
+ std::ostream m_os;
+
+ public:
+ // Store the streambuf from cerr up-front because
+ // cout may get redirected when running tests
+ CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
+
+ public: // IStream
+ std::ostream& stream() override { return m_os; }
+ bool isConsole() const override { return true; }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+
+ class DebugOutStream final : public IStream {
+ Detail::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
+ std::ostream m_os;
+ public:
+ DebugOutStream()
+ : m_streamBuf( Detail::make_unique<StreamBufImpl<OutputDebugWriter>>() ),
+ m_os( m_streamBuf.get() )
+ {}
+
+ public: // IStream
+ std::ostream& stream() override { return m_os; }
+ };
+
+ } // unnamed namespace
+} // namespace Detail
+
+ ///////////////////////////////////////////////////////////////////////////
+
+ auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream> {
+ if ( filename.empty() || filename == "-" ) {
+ return Detail::make_unique<Detail::CoutStream>();
+ }
+ if( filename[0] == '%' ) {
+ if ( filename == "%debug" ) {
+ return Detail::make_unique<Detail::DebugOutStream>();
+ } else if ( filename == "%stderr" ) {
+ return Detail::make_unique<Detail::CerrStream>();
+ } else if ( filename == "%stdout" ) {
+ return Detail::make_unique<Detail::CoutStream>();
+ } else {
+ CATCH_ERROR( "Unrecognised stream: '" << filename << '\'' );
+ }
+ }
+ return Detail::make_unique<Detail::FileStream>( filename );
+ }
+
+}
+
+
+
+namespace Catch {
+ void JsonUtils::indent( std::ostream& os, std::uint64_t level ) {
+ for ( std::uint64_t i = 0; i < level; ++i ) {
+ os << " ";
+ }
+ }
+ void JsonUtils::appendCommaNewline( std::ostream& os,
+ bool& should_comma,
+ std::uint64_t level ) {
+ if ( should_comma ) { os << ','; }
+ should_comma = true;
+ os << '\n';
+ indent( os, level );
+ }
+
+ JsonObjectWriter::JsonObjectWriter( std::ostream& os ):
+ JsonObjectWriter{ os, 0 } {}
+
+ JsonObjectWriter::JsonObjectWriter( std::ostream& os,
+ std::uint64_t indent_level ):
+ m_os{ os }, m_indent_level{ indent_level } {
+ m_os << '{';
+ }
+ JsonObjectWriter::JsonObjectWriter( JsonObjectWriter&& source ) noexcept:
+ m_os{ source.m_os },
+ m_indent_level{ source.m_indent_level },
+ m_should_comma{ source.m_should_comma },
+ m_active{ source.m_active } {
+ source.m_active = false;
+ }
+
+ JsonObjectWriter::~JsonObjectWriter() {
+ if ( !m_active ) { return; }
+
+ m_os << '\n';
+ JsonUtils::indent( m_os, m_indent_level );
+ m_os << '}';
+ }
+
+ JsonValueWriter JsonObjectWriter::write( StringRef key ) {
+ JsonUtils::appendCommaNewline(
+ m_os, m_should_comma, m_indent_level + 1 );
+
+ m_os << '"' << key << "\": ";
+ return JsonValueWriter{ m_os, m_indent_level + 1 };
+ }
+
+ JsonArrayWriter::JsonArrayWriter( std::ostream& os ):
+ JsonArrayWriter{ os, 0 } {}
+ JsonArrayWriter::JsonArrayWriter( std::ostream& os,
+ std::uint64_t indent_level ):
+ m_os{ os }, m_indent_level{ indent_level } {
+ m_os << '[';
+ }
+ JsonArrayWriter::JsonArrayWriter( JsonArrayWriter&& source ) noexcept:
+ m_os{ source.m_os },
+ m_indent_level{ source.m_indent_level },
+ m_should_comma{ source.m_should_comma },
+ m_active{ source.m_active } {
+ source.m_active = false;
+ }
+ JsonArrayWriter::~JsonArrayWriter() {
+ if ( !m_active ) { return; }
+
+ m_os << '\n';
+ JsonUtils::indent( m_os, m_indent_level );
+ m_os << ']';
+ }
+
+ JsonObjectWriter JsonArrayWriter::writeObject() {
+ JsonUtils::appendCommaNewline(
+ m_os, m_should_comma, m_indent_level + 1 );
+ return JsonObjectWriter{ m_os, m_indent_level + 1 };
+ }
+
+ JsonArrayWriter JsonArrayWriter::writeArray() {
+ JsonUtils::appendCommaNewline(
+ m_os, m_should_comma, m_indent_level + 1 );
+ return JsonArrayWriter{ m_os, m_indent_level + 1 };
+ }
+
+ JsonArrayWriter& JsonArrayWriter::write( bool value ) {
+ return writeImpl( value );
+ }
+
+ JsonValueWriter::JsonValueWriter( std::ostream& os ):
+ JsonValueWriter{ os, 0 } {}
+
+ JsonValueWriter::JsonValueWriter( std::ostream& os,
+ std::uint64_t indent_level ):
+ m_os{ os }, m_indent_level{ indent_level } {}
+
+ JsonObjectWriter JsonValueWriter::writeObject() && {
+ return JsonObjectWriter{ m_os, m_indent_level };
+ }
+
+ JsonArrayWriter JsonValueWriter::writeArray() && {
+ return JsonArrayWriter{ m_os, m_indent_level };
+ }
+
+ void JsonValueWriter::write( Catch::StringRef value ) && {
+ writeImpl( value, true );
+ }
+
+ void JsonValueWriter::write( bool value ) && {
+ writeImpl( value ? "true"_sr : "false"_sr, false );
+ }
+
+ void JsonValueWriter::writeImpl( Catch::StringRef value, bool quote ) {
+ if ( quote ) { m_os << '"'; }
+ for (char c : value) {
+ // Escape list taken from https://www.json.org/json-en.html,
+ // string definition.
+ // Note that while forward slash _can_ be escaped, it does
+ // not have to be, if JSON is not further embedded somewhere
+ // where forward slash is meaningful.
+ if ( c == '"' ) {
+ m_os << "\\\"";
+ } else if ( c == '\\' ) {
+ m_os << "\\\\";
+ } else if ( c == '\b' ) {
+ m_os << "\\b";
+ } else if ( c == '\f' ) {
+ m_os << "\\f";
+ } else if ( c == '\n' ) {
+ m_os << "\\n";
+ } else if ( c == '\r' ) {
+ m_os << "\\r";
+ } else if ( c == '\t' ) {
+ m_os << "\\t";
+ } else {
+ m_os << c;
+ }
+ }
+ if ( quote ) { m_os << '"'; }
+ }
+
+} // namespace Catch
+
+
+
+
+namespace Catch {
+
+ auto operator << (std::ostream& os, LazyExpression const& lazyExpr) -> std::ostream& {
+ if (lazyExpr.m_isNegated)
+ os << '!';
+
+ if (lazyExpr) {
+ if (lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression())
+ os << '(' << *lazyExpr.m_transientExpression << ')';
+ else
+ os << *lazyExpr.m_transientExpression;
+ } else {
+ os << "{** error - unchecked empty expression requested **}";
+ }
+ return os;
+ }
+
+} // namespace Catch
+
+
+
+
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
+
+namespace Catch {
+
+ LeakDetector::LeakDetector() {
+ int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+ flag |= _CRTDBG_LEAK_CHECK_DF;
+ flag |= _CRTDBG_ALLOC_MEM_DF;
+ _CrtSetDbgFlag(flag);
+ _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+ _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+ // Change this to leaking allocation's number to break there
+ _CrtSetBreakAlloc(-1);
+ }
+}
+
+#else // ^^ Windows crt debug heap enabled // Windows crt debug heap disabled vv
+
+ Catch::LeakDetector::LeakDetector() = default;
+
+#endif // CATCH_CONFIG_WINDOWS_CRTDBG
+
+Catch::LeakDetector::~LeakDetector() {
+ Catch::cleanUp();
+}
+
+
+
+
+namespace Catch {
+ namespace {
+
+ void listTests(IEventListener& reporter, IConfig const& config) {
+ auto const& testSpec = config.testSpec();
+ auto matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+ reporter.listTests(matchedTestCases);
+ }
+
+ void listTags(IEventListener& reporter, IConfig const& config) {
+ auto const& testSpec = config.testSpec();
+ std::vector<TestCaseHandle> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+
+ std::map<StringRef, TagInfo, Detail::CaseInsensitiveLess> tagCounts;
+ for (auto const& testCase : matchedTestCases) {
+ for (auto const& tagName : testCase.getTestCaseInfo().tags) {
+ auto it = tagCounts.find(tagName.original);
+ if (it == tagCounts.end())
+ it = tagCounts.insert(std::make_pair(tagName.original, TagInfo())).first;
+ it->second.add(tagName.original);
+ }
+ }
+
+ std::vector<TagInfo> infos; infos.reserve(tagCounts.size());
+ for (auto& tagc : tagCounts) {
+ infos.push_back(CATCH_MOVE(tagc.second));
+ }
+
+ reporter.listTags(infos);
+ }
+
+ void listReporters(IEventListener& reporter) {
+ std::vector<ReporterDescription> descriptions;
+
+ auto const& factories = getRegistryHub().getReporterRegistry().getFactories();
+ descriptions.reserve(factories.size());
+ for (auto const& fac : factories) {
+ descriptions.push_back({ fac.first, fac.second->getDescription() });
+ }
+
+ reporter.listReporters(descriptions);
+ }
+
+ void listListeners(IEventListener& reporter) {
+ std::vector<ListenerDescription> descriptions;
+
+ auto const& factories =
+ getRegistryHub().getReporterRegistry().getListeners();
+ descriptions.reserve( factories.size() );
+ for ( auto const& fac : factories ) {
+ descriptions.push_back( { fac->getName(), fac->getDescription() } );
+ }
+
+ reporter.listListeners( descriptions );
+ }
+
+ } // end anonymous namespace
+
+ void TagInfo::add( StringRef spelling ) {
+ ++count;
+ spellings.insert( spelling );
+ }
+
+ std::string TagInfo::all() const {
+ // 2 per tag for brackets '[' and ']'
+ size_t size = spellings.size() * 2;
+ for (auto const& spelling : spellings) {
+ size += spelling.size();
+ }
+
+ std::string out; out.reserve(size);
+ for (auto const& spelling : spellings) {
+ out += '[';
+ out += spelling;
+ out += ']';
+ }
+ return out;
+ }
+
+ bool list( IEventListener& reporter, Config const& config ) {
+ bool listed = false;
+ if (config.listTests()) {
+ listed = true;
+ listTests(reporter, config);
+ }
+ if (config.listTags()) {
+ listed = true;
+ listTags(reporter, config);
+ }
+ if (config.listReporters()) {
+ listed = true;
+ listReporters(reporter);
+ }
+ if ( config.listListeners() ) {
+ listed = true;
+ listListeners( reporter );
+ }
+ return listed;
+ }
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+ static LeakDetector leakDetector;
+ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+}
+
+// Allow users of amalgamated .cpp file to remove our main and provide their own.
+#if !defined(CATCH_AMALGAMATED_CUSTOM_MAIN)
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+// Standard C/C++ Win32 Unicode wmain entry point
+extern "C" int __cdecl wmain (int argc, wchar_t * argv[], wchar_t * []) {
+#else
+// Standard C/C++ main entry point
+int main (int argc, char * argv[]) {
+#endif
+
+ // We want to force the linker not to discard the global variable
+ // and its constructor, as it (optionally) registers leak detector
+ (void)&Catch::leakDetector;
+
+ return Catch::Session().run( argc, argv );
+}
+
+#endif // !defined(CATCH_AMALGAMATED_CUSTOM_MAIN
+
+
+
+
+namespace Catch {
+
+ MessageInfo::MessageInfo( StringRef _macroName,
+ SourceLineInfo const& _lineInfo,
+ ResultWas::OfType _type )
+ : macroName( _macroName ),
+ lineInfo( _lineInfo ),
+ type( _type ),
+ sequence( ++globalCount )
+ {}
+
+ // This may need protecting if threading support is added
+ unsigned int MessageInfo::globalCount = 0;
+
+} // end namespace Catch
+
+
+
+#include <cstdio>
+#include <cstring>
+#include <sstream>
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+ #if defined(_MSC_VER)
+ #include <io.h> //_dup and _dup2
+ #define dup _dup
+ #define dup2 _dup2
+ #define fileno _fileno
+ #else
+ #include <unistd.h> // dup and dup2
+ #endif
+#endif
+
+
+namespace Catch {
+
+ RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
+ : m_originalStream( originalStream ),
+ m_redirectionStream( redirectionStream ),
+ m_prevBuf( m_originalStream.rdbuf() )
+ {
+ m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
+ }
+
+ RedirectedStream::~RedirectedStream() {
+ m_originalStream.rdbuf( m_prevBuf );
+ }
+
+ RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
+ auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
+
+ RedirectedStdErr::RedirectedStdErr()
+ : m_cerr( Catch::cerr(), m_rss.get() ),
+ m_clog( Catch::clog(), m_rss.get() )
+ {}
+ auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
+
+ RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
+ : m_redirectedCout(redirectedCout),
+ m_redirectedCerr(redirectedCerr)
+ {}
+
+ RedirectedStreams::~RedirectedStreams() {
+ m_redirectedCout += m_redirectedStdOut.str();
+ m_redirectedCerr += m_redirectedStdErr.str();
+ }
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+#if defined(_MSC_VER)
+ TempFile::TempFile() {
+ if (tmpnam_s(m_buffer)) {
+ CATCH_RUNTIME_ERROR("Could not get a temp filename");
+ }
+ if (fopen_s(&m_file, m_buffer, "w+")) {
+ char buffer[100];
+ if (strerror_s(buffer, errno)) {
+ CATCH_RUNTIME_ERROR("Could not translate errno to a string");
+ }
+ CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
+ }
+ }
+#else
+ TempFile::TempFile() {
+ m_file = std::tmpfile();
+ if (!m_file) {
+ CATCH_RUNTIME_ERROR("Could not create a temp file.");
+ }
+ }
+
+#endif
+
+ TempFile::~TempFile() {
+ // TBD: What to do about errors here?
+ std::fclose(m_file);
+ // We manually create the file on Windows only, on Linux
+ // it will be autodeleted
+#if defined(_MSC_VER)
+ std::remove(m_buffer);
+#endif
+ }
+
+
+ FILE* TempFile::getFile() {
+ return m_file;
+ }
+
+ std::string TempFile::getContents() {
+ std::stringstream sstr;
+ char buffer[100] = {};
+ std::rewind(m_file);
+ while (std::fgets(buffer, sizeof(buffer), m_file)) {
+ sstr << buffer;
+ }
+ return sstr.str();
+ }
+
+ OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
+ m_originalStdout(dup(1)),
+ m_originalStderr(dup(2)),
+ m_stdoutDest(stdout_dest),
+ m_stderrDest(stderr_dest) {
+ dup2(fileno(m_stdoutFile.getFile()), 1);
+ dup2(fileno(m_stderrFile.getFile()), 2);
+ }
+
+ OutputRedirect::~OutputRedirect() {
+ Catch::cout() << std::flush;
+ fflush(stdout);
+ // Since we support overriding these streams, we flush cerr
+ // even though std::cerr is unbuffered
+ Catch::cerr() << std::flush;
+ Catch::clog() << std::flush;
+ fflush(stderr);
+
+ dup2(m_originalStdout, 1);
+ dup2(m_originalStderr, 2);
+
+ m_stdoutDest += m_stdoutFile.getContents();
+ m_stderrDest += m_stderrFile.getContents();
+ }
+
+#endif // CATCH_CONFIG_NEW_CAPTURE
+
+} // namespace Catch
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+ #if defined(_MSC_VER)
+ #undef dup
+ #undef dup2
+ #undef fileno
+ #endif
+#endif
+
+
+
+
+#include <limits>
+#include <stdexcept>
+
+namespace Catch {
+
+ Optional<unsigned int> parseUInt(std::string const& input, int base) {
+ auto trimmed = trim( input );
+ // std::stoull is annoying and accepts numbers starting with '-',
+ // it just negates them into unsigned int
+ if ( trimmed.empty() || trimmed[0] == '-' ) {
+ return {};
+ }
+
+ CATCH_TRY {
+ size_t pos = 0;
+ const auto ret = std::stoull( trimmed, &pos, base );
+
+ // We did not consume the whole input, so there is an issue
+ // This can be bunch of different stuff, like multiple numbers
+ // in the input, or invalid digits/characters and so on. Either
+ // way, we do not want to return the partially parsed result.
+ if ( pos != trimmed.size() ) {
+ return {};
+ }
+ // Too large
+ if ( ret > std::numeric_limits<unsigned int>::max() ) {
+ return {};
+ }
+ return static_cast<unsigned int>(ret);
+ }
+ CATCH_CATCH_ANON( std::invalid_argument const& ) {
+ // no conversion could be performed
+ }
+ CATCH_CATCH_ANON( std::out_of_range const& ) {
+ // the input does not fit into an unsigned long long
+ }
+ return {};
+ }
+
+} // namespace Catch
+
+
+
+
+#include <cmath>
+
+namespace Catch {
+
+#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+ bool isnan(float f) {
+ return std::isnan(f);
+ }
+ bool isnan(double d) {
+ return std::isnan(d);
+ }
+#else
+ // For now we only use this for embarcadero
+ bool isnan(float f) {
+ return std::_isnan(f);
+ }
+ bool isnan(double d) {
+ return std::_isnan(d);
+ }
+#endif
+
+#if !defined( CATCH_CONFIG_GLOBAL_NEXTAFTER )
+ float nextafter( float x, float y ) { return std::nextafter( x, y ); }
+ double nextafter( double x, double y ) { return std::nextafter( x, y ); }
+#else
+ float nextafter( float x, float y ) { return ::nextafterf( x, y ); }
+ double nextafter( double x, double y ) { return ::nextafter( x, y ); }
+#endif
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+namespace {
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4146) // we negate uint32 during the rotate
+#endif
+ // Safe rotr implementation thanks to John Regehr
+ uint32_t rotate_right(uint32_t val, uint32_t count) {
+ const uint32_t mask = 31;
+ count &= mask;
+ return (val >> count) | (val << (-count & mask));
+ }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}
+
+
+ SimplePcg32::SimplePcg32(result_type seed_) {
+ seed(seed_);
+ }
+
+
+ void SimplePcg32::seed(result_type seed_) {
+ m_state = 0;
+ (*this)();
+ m_state += seed_;
+ (*this)();
+ }
+
+ void SimplePcg32::discard(uint64_t skip) {
+ // We could implement this to run in O(log n) steps, but this
+ // should suffice for our use case.
+ for (uint64_t s = 0; s < skip; ++s) {
+ static_cast<void>((*this)());
+ }
+ }
+
+ SimplePcg32::result_type SimplePcg32::operator()() {
+ // prepare the output value
+ const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
+ const auto output = rotate_right(xorshifted, m_state >> 59u);
+
+ // advance state
+ m_state = m_state * 6364136223846793005ULL + s_inc;
+
+ return output;
+ }
+
+ bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+ return lhs.m_state == rhs.m_state;
+ }
+
+ bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+ return lhs.m_state != rhs.m_state;
+ }
+}
+
+
+
+
+
+#include <ctime>
+#include <random>
+
+namespace Catch {
+
+ std::uint32_t generateRandomSeed( GenerateFrom from ) {
+ switch ( from ) {
+ case GenerateFrom::Time:
+ return static_cast<std::uint32_t>( std::time( nullptr ) );
+
+ case GenerateFrom::Default:
+ case GenerateFrom::RandomDevice: {
+ std::random_device rd;
+ return Detail::fillBitsFrom<std::uint32_t>( rd );
+ }
+
+ default:
+ CATCH_ERROR("Unknown generation method");
+ }
+ }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+ struct ReporterRegistry::ReporterRegistryImpl {
+ std::vector<Detail::unique_ptr<EventListenerFactory>> listeners;
+ std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess>
+ factories;
+ };
+
+ ReporterRegistry::ReporterRegistry():
+ m_impl( Detail::make_unique<ReporterRegistryImpl>() ) {
+ // Because it is impossible to move out of initializer list,
+ // we have to add the elements manually
+ m_impl->factories["Automake"] =
+ Detail::make_unique<ReporterFactory<AutomakeReporter>>();
+ m_impl->factories["compact"] =
+ Detail::make_unique<ReporterFactory<CompactReporter>>();
+ m_impl->factories["console"] =
+ Detail::make_unique<ReporterFactory<ConsoleReporter>>();
+ m_impl->factories["JUnit"] =
+ Detail::make_unique<ReporterFactory<JunitReporter>>();
+ m_impl->factories["SonarQube"] =
+ Detail::make_unique<ReporterFactory<SonarQubeReporter>>();
+ m_impl->factories["TAP"] =
+ Detail::make_unique<ReporterFactory<TAPReporter>>();
+ m_impl->factories["TeamCity"] =
+ Detail::make_unique<ReporterFactory<TeamCityReporter>>();
+ m_impl->factories["XML"] =
+ Detail::make_unique<ReporterFactory<XmlReporter>>();
+ m_impl->factories["JSON"] =
+ Detail::make_unique<ReporterFactory<JsonReporter>>();
+ }
+
+ ReporterRegistry::~ReporterRegistry() = default;
+
+ IEventListenerPtr
+ ReporterRegistry::create( std::string const& name,
+ ReporterConfig&& config ) const {
+ auto it = m_impl->factories.find( name );
+ if ( it == m_impl->factories.end() ) return nullptr;
+ return it->second->create( CATCH_MOVE( config ) );
+ }
+
+ void ReporterRegistry::registerReporter( std::string const& name,
+ IReporterFactoryPtr factory ) {
+ CATCH_ENFORCE( name.find( "::" ) == name.npos,
+ "'::' is not allowed in reporter name: '" + name +
+ '\'' );
+ auto ret = m_impl->factories.emplace( name, CATCH_MOVE( factory ) );
+ CATCH_ENFORCE( ret.second,
+ "reporter using '" + name +
+ "' as name was already registered" );
+ }
+ void ReporterRegistry::registerListener(
+ Detail::unique_ptr<EventListenerFactory> factory ) {
+ m_impl->listeners.push_back( CATCH_MOVE( factory ) );
+ }
+
+ std::map<std::string,
+ IReporterFactoryPtr,
+ Detail::CaseInsensitiveLess> const&
+ ReporterRegistry::getFactories() const {
+ return m_impl->factories;
+ }
+
+ std::vector<Detail::unique_ptr<EventListenerFactory>> const&
+ ReporterRegistry::getListeners() const {
+ return m_impl->listeners;
+ }
+} // namespace Catch
+
+
+
+
+
+#include <algorithm>
+
+namespace Catch {
+
+ namespace {
+ struct kvPair {
+ StringRef key, value;
+ };
+
+ kvPair splitKVPair(StringRef kvString) {
+ auto splitPos = static_cast<size_t>(
+ std::find( kvString.begin(), kvString.end(), '=' ) -
+ kvString.begin() );
+
+ return { kvString.substr( 0, splitPos ),
+ kvString.substr( splitPos + 1, kvString.size() ) };
+ }
+ }
+
+ namespace Detail {
+ std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
+ static constexpr auto separator = "::";
+ static constexpr size_t separatorSize = 2;
+
+ size_t separatorPos = 0;
+ auto findNextSeparator = [&reporterSpec]( size_t startPos ) {
+ static_assert(
+ separatorSize == 2,
+ "The code below currently assumes 2 char separator" );
+
+ auto currentPos = startPos;
+ do {
+ while ( currentPos < reporterSpec.size() &&
+ reporterSpec[currentPos] != separator[0] ) {
+ ++currentPos;
+ }
+ if ( currentPos + 1 < reporterSpec.size() &&
+ reporterSpec[currentPos + 1] == separator[1] ) {
+ return currentPos;
+ }
+ ++currentPos;
+ } while ( currentPos < reporterSpec.size() );
+
+ return static_cast<size_t>( -1 );
+ };
+
+ std::vector<std::string> parts;
+
+ while ( separatorPos < reporterSpec.size() ) {
+ const auto nextSeparator = findNextSeparator( separatorPos );
+ parts.push_back( static_cast<std::string>( reporterSpec.substr(
+ separatorPos, nextSeparator - separatorPos ) ) );
+
+ if ( nextSeparator == static_cast<size_t>( -1 ) ) {
+ break;
+ }
+ separatorPos = nextSeparator + separatorSize;
+ }
+
+ // Handle a separator at the end.
+ // This is not a valid spec, but we want to do validation in a
+ // centralized place
+ if ( separatorPos == reporterSpec.size() ) {
+ parts.emplace_back();
+ }
+
+ return parts;
+ }
+
+ Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
+ if ( colourMode == "default" ) {
+ return ColourMode::PlatformDefault;
+ } else if ( colourMode == "ansi" ) {
+ return ColourMode::ANSI;
+ } else if ( colourMode == "win32" ) {
+ return ColourMode::Win32;
+ } else if ( colourMode == "none" ) {
+ return ColourMode::None;
+ } else {
+ return {};
+ }
+ }
+ } // namespace Detail
+
+
+ bool operator==( ReporterSpec const& lhs, ReporterSpec const& rhs ) {
+ return lhs.m_name == rhs.m_name &&
+ lhs.m_outputFileName == rhs.m_outputFileName &&
+ lhs.m_colourMode == rhs.m_colourMode &&
+ lhs.m_customOptions == rhs.m_customOptions;
+ }
+
+ Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec ) {
+ auto parts = Detail::splitReporterSpec( reporterSpec );
+
+ assert( parts.size() > 0 && "Split should never return empty vector" );
+
+ std::map<std::string, std::string> kvPairs;
+ Optional<std::string> outputFileName;
+ Optional<ColourMode> colourMode;
+
+ // First part is always reporter name, so we skip it
+ for ( size_t i = 1; i < parts.size(); ++i ) {
+ auto kv = splitKVPair( parts[i] );
+ auto key = kv.key, value = kv.value;
+
+ if ( key.empty() || value.empty() ) { // NOLINT(bugprone-branch-clone)
+ return {};
+ } else if ( key[0] == 'X' ) {
+ // This is a reporter-specific option, we don't check these
+ // apart from basic sanity checks
+ if ( key.size() == 1 ) {
+ return {};
+ }
+
+ auto ret = kvPairs.emplace( std::string(kv.key), std::string(kv.value) );
+ if ( !ret.second ) {
+ // Duplicated key. We might want to handle this differently,
+ // e.g. by overwriting the existing value?
+ return {};
+ }
+ } else if ( key == "out" ) {
+ // Duplicated key
+ if ( outputFileName ) {
+ return {};
+ }
+ outputFileName = static_cast<std::string>( value );
+ } else if ( key == "colour-mode" ) {
+ // Duplicated key
+ if ( colourMode ) {
+ return {};
+ }
+ colourMode = Detail::stringToColourMode( value );
+ // Parsing failed
+ if ( !colourMode ) {
+ return {};
+ }
+ } else {
+ // Unrecognized option
+ return {};
+ }
+ }
+
+ return ReporterSpec{ CATCH_MOVE( parts[0] ),
+ CATCH_MOVE( outputFileName ),
+ CATCH_MOVE( colourMode ),
+ CATCH_MOVE( kvPairs ) };
+ }
+
+ReporterSpec::ReporterSpec(
+ std::string name,
+ Optional<std::string> outputFileName,
+ Optional<ColourMode> colourMode,
+ std::map<std::string, std::string> customOptions ):
+ m_name( CATCH_MOVE( name ) ),
+ m_outputFileName( CATCH_MOVE( outputFileName ) ),
+ m_colourMode( CATCH_MOVE( colourMode ) ),
+ m_customOptions( CATCH_MOVE( customOptions ) ) {}
+
+} // namespace Catch
+
+
+
+namespace Catch {
+
+ bool isOk( ResultWas::OfType resultType ) {
+ return ( resultType & ResultWas::FailureBit ) == 0;
+ }
+ bool isJustInfo( int flags ) {
+ return flags == ResultWas::Info;
+ }
+
+ ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+ return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+ }
+
+ bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+ bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+
+
+
+#include <cstdio>
+#include <sstream>
+#include <vector>
+
+namespace Catch {
+
+ // This class encapsulates the idea of a pool of ostringstreams that can be reused.
+ struct StringStreams {
+ std::vector<Detail::unique_ptr<std::ostringstream>> m_streams;
+ std::vector<std::size_t> m_unused;
+ std::ostringstream m_referenceStream; // Used for copy state/ flags from
+
+ auto add() -> std::size_t {
+ if( m_unused.empty() ) {
+ m_streams.push_back( Detail::make_unique<std::ostringstream>() );
+ return m_streams.size()-1;
+ }
+ else {
+ auto index = m_unused.back();
+ m_unused.pop_back();
+ return index;
+ }
+ }
+
+ void release( std::size_t index ) {
+ m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
+ m_unused.push_back(index);
+ }
+ };
+
+ ReusableStringStream::ReusableStringStream()
+ : m_index( Singleton<StringStreams>::getMutable().add() ),
+ m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
+ {}
+
+ ReusableStringStream::~ReusableStringStream() {
+ static_cast<std::ostringstream*>( m_oss )->str("");
+ m_oss->clear();
+ Singleton<StringStreams>::getMutable().release( m_index );
+ }
+
+ std::string ReusableStringStream::str() const {
+ return static_cast<std::ostringstream*>( m_oss )->str();
+ }
+
+ void ReusableStringStream::str( std::string const& str ) {
+ static_cast<std::ostringstream*>( m_oss )->str( str );
+ }
+
+
+}
+
+
+
+
+#include <cassert>
+#include <algorithm>
+
+namespace Catch {
+
+ namespace Generators {
+ namespace {
+ struct GeneratorTracker final : TestCaseTracking::TrackerBase,
+ IGeneratorTracker {
+ GeneratorBasePtr m_generator;
+
+ GeneratorTracker(
+ TestCaseTracking::NameAndLocation&& nameAndLocation,
+ TrackerContext& ctx,
+ ITracker* parent ):
+ TrackerBase( CATCH_MOVE( nameAndLocation ), ctx, parent ) {}
+
+ static GeneratorTracker*
+ acquire( TrackerContext& ctx,
+ TestCaseTracking::NameAndLocationRef const&
+ nameAndLocation ) {
+ GeneratorTracker* tracker;
+
+ ITracker& currentTracker = ctx.currentTracker();
+ // Under specific circumstances, the generator we want
+ // to acquire is also the current tracker. If this is
+ // the case, we have to avoid looking through current
+ // tracker's children, and instead return the current
+ // tracker.
+ // A case where this check is important is e.g.
+ // for (int i = 0; i < 5; ++i) {
+ // int n = GENERATE(1, 2);
+ // }
+ //
+ // without it, the code above creates 5 nested generators.
+ if ( currentTracker.nameAndLocation() == nameAndLocation ) {
+ auto thisTracker = currentTracker.parent()->findChild(
+ nameAndLocation );
+ assert( thisTracker );
+ assert( thisTracker->isGeneratorTracker() );
+ tracker = static_cast<GeneratorTracker*>( thisTracker );
+ } else if ( ITracker* childTracker =
+ currentTracker.findChild(
+ nameAndLocation ) ) {
+ assert( childTracker );
+ assert( childTracker->isGeneratorTracker() );
+ tracker =
+ static_cast<GeneratorTracker*>( childTracker );
+ } else {
+ return nullptr;
+ }
+
+ if ( !tracker->isComplete() ) { tracker->open(); }
+
+ return tracker;
+ }
+
+ // TrackerBase interface
+ bool isGeneratorTracker() const override { return true; }
+ auto hasGenerator() const -> bool override {
+ return !!m_generator;
+ }
+ void close() override {
+ TrackerBase::close();
+ // If a generator has a child (it is followed by a section)
+ // and none of its children have started, then we must wait
+ // until later to start consuming its values.
+ // This catches cases where `GENERATE` is placed between two
+ // `SECTION`s.
+ // **The check for m_children.empty cannot be removed**.
+ // doing so would break `GENERATE` _not_ followed by
+ // `SECTION`s.
+ const bool should_wait_for_child = [&]() {
+ // No children -> nobody to wait for
+ if ( m_children.empty() ) { return false; }
+ // If at least one child started executing, don't wait
+ if ( std::find_if(
+ m_children.begin(),
+ m_children.end(),
+ []( TestCaseTracking::ITrackerPtr const&
+ tracker ) {
+ return tracker->hasStarted();
+ } ) != m_children.end() ) {
+ return false;
+ }
+
+ // No children have started. We need to check if they
+ // _can_ start, and thus we should wait for them, or
+ // they cannot start (due to filters), and we shouldn't
+ // wait for them
+ ITracker* parent = m_parent;
+ // This is safe: there is always at least one section
+ // tracker in a test case tracking tree
+ while ( !parent->isSectionTracker() ) {
+ parent = parent->parent();
+ }
+ assert( parent &&
+ "Missing root (test case) level section" );
+
+ auto const& parentSection =
+ static_cast<SectionTracker const&>( *parent );
+ auto const& filters = parentSection.getFilters();
+ // No filters -> no restrictions on running sections
+ if ( filters.empty() ) { return true; }
+
+ for ( auto const& child : m_children ) {
+ if ( child->isSectionTracker() &&
+ std::find( filters.begin(),
+ filters.end(),
+ static_cast<SectionTracker const&>(
+ *child )
+ .trimmedName() ) !=
+ filters.end() ) {
+ return true;
+ }
+ }
+ return false;
+ }();
+
+ // This check is a bit tricky, because m_generator->next()
+ // has a side-effect, where it consumes generator's current
+ // value, but we do not want to invoke the side-effect if
+ // this generator is still waiting for any child to start.
+ assert( m_generator && "Tracker without generator" );
+ if ( should_wait_for_child ||
+ ( m_runState == CompletedSuccessfully &&
+ m_generator->countedNext() ) ) {
+ m_children.clear();
+ m_runState = Executing;
+ }
+ }
+
+ // IGeneratorTracker interface
+ auto getGenerator() const -> GeneratorBasePtr const& override {
+ return m_generator;
+ }
+ void setGenerator( GeneratorBasePtr&& generator ) override {
+ m_generator = CATCH_MOVE( generator );
+ }
+ };
+ } // namespace
+ }
+
+ RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
+ : m_runInfo(_config->name()),
+ m_config(_config),
+ m_reporter(CATCH_MOVE(reporter)),
+ m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
+ m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
+ {
+ getCurrentMutableContext().setResultCapture( this );
+ m_reporter->testRunStarting(m_runInfo);
+ }
+
+ RunContext::~RunContext() {
+ m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+ }
+
+ Totals RunContext::runTest(TestCaseHandle const& testCase) {
+ const Totals prevTotals = m_totals;
+
+ auto const& testInfo = testCase.getTestCaseInfo();
+ m_reporter->testCaseStarting(testInfo);
+ m_activeTestCase = &testCase;
+
+
+ ITracker& rootTracker = m_trackerContext.startRun();
+ assert(rootTracker.isSectionTracker());
+ static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
+
+ // We intentionally only seed the internal RNG once per test case,
+ // before it is first invoked. The reason for that is a complex
+ // interplay of generator/section implementation details and the
+ // Random*Generator types.
+ //
+ // The issue boils down to us needing to seed the Random*Generators
+ // with different seed each, so that they return different sequences
+ // of random numbers. We do this by giving them a number from the
+ // shared RNG instance as their seed.
+ //
+ // However, this runs into an issue if the reseeding happens each
+ // time the test case is entered (as opposed to first time only),
+ // because multiple generators could get the same seed, e.g. in
+ // ```cpp
+ // TEST_CASE() {
+ // auto i = GENERATE(take(10, random(0, 100));
+ // SECTION("A") {
+ // auto j = GENERATE(take(10, random(0, 100));
+ // }
+ // SECTION("B") {
+ // auto k = GENERATE(take(10, random(0, 100));
+ // }
+ // }
+ // ```
+ // `i` and `j` would properly return values from different sequences,
+ // but `i` and `k` would return the same sequence, because their seed
+ // would be the same.
+ // (The reason their seeds would be the same is that the generator
+ // for k would be initialized when the test case is entered the second
+ // time, after the shared RNG instance was reset to the same value
+ // it had when the generator for i was initialized.)
+ seedRng( *m_config );
+
+ uint64_t testRuns = 0;
+ std::string redirectedCout;
+ std::string redirectedCerr;
+ do {
+ m_trackerContext.startCycle();
+ m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));
+
+ m_reporter->testCasePartialStarting(testInfo, testRuns);
+
+ const auto beforeRunTotals = m_totals;
+ std::string oneRunCout, oneRunCerr;
+ runCurrentTest(oneRunCout, oneRunCerr);
+ redirectedCout += oneRunCout;
+ redirectedCerr += oneRunCerr;
+
+ const auto singleRunTotals = m_totals.delta(beforeRunTotals);
+ auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
+
+ m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
+ ++testRuns;
+ } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
+
+ Totals deltaTotals = m_totals.delta(prevTotals);
+ if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
+ deltaTotals.assertions.failed++;
+ deltaTotals.testCases.passed--;
+ deltaTotals.testCases.failed++;
+ }
+ m_totals.testCases += deltaTotals.testCases;
+ m_reporter->testCaseEnded(TestCaseStats(testInfo,
+ deltaTotals,
+ CATCH_MOVE(redirectedCout),
+ CATCH_MOVE(redirectedCerr),
+ aborting()));
+
+ m_activeTestCase = nullptr;
+ m_testCaseTracker = nullptr;
+
+ return deltaTotals;
+ }
+
+
+ void RunContext::assertionEnded(AssertionResult&& result) {
+ if (result.getResultType() == ResultWas::Ok) {
+ m_totals.assertions.passed++;
+ m_lastAssertionPassed = true;
+ } else if (result.getResultType() == ResultWas::ExplicitSkip) {
+ m_totals.assertions.skipped++;
+ m_lastAssertionPassed = true;
+ } else if (!result.succeeded()) {
+ m_lastAssertionPassed = false;
+ if (result.isOk()) {
+ }
+ else if( m_activeTestCase->getTestCaseInfo().okToFail() )
+ m_totals.assertions.failedButOk++;
+ else
+ m_totals.assertions.failed++;
+ }
+ else {
+ m_lastAssertionPassed = true;
+ }
+
+ m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals));
+
+ if ( result.getResultType() != ResultWas::Warning ) {
+ m_messageScopes.clear();
+ }
+
+ // Reset working state. assertion info will be reset after
+ // populateReaction is run if it is needed
+ m_lastResult = CATCH_MOVE( result );
+ }
+ void RunContext::resetAssertionInfo() {
+ m_lastAssertionInfo.macroName = StringRef();
+ m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
+ m_lastAssertionInfo.resultDisposition = ResultDisposition::Normal;
+ }
+
+ void RunContext::notifyAssertionStarted( AssertionInfo const& info ) {
+ m_reporter->assertionStarting( info );
+ }
+
+ bool RunContext::sectionStarted( StringRef sectionName,
+ SourceLineInfo const& sectionLineInfo,
+ Counts& assertions ) {
+ ITracker& sectionTracker =
+ SectionTracker::acquire( m_trackerContext,
+ TestCaseTracking::NameAndLocationRef(
+ sectionName, sectionLineInfo ) );
+
+ if (!sectionTracker.isOpen())
+ return false;
+ m_activeSections.push_back(§ionTracker);
+
+ SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) );
+ m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+ m_reporter->sectionStarting(sectionInfo);
+
+ assertions = m_totals.assertions;
+
+ return true;
+ }
+ IGeneratorTracker*
+ RunContext::acquireGeneratorTracker( StringRef generatorName,
+ SourceLineInfo const& lineInfo ) {
+ using namespace Generators;
+ GeneratorTracker* tracker = GeneratorTracker::acquire(
+ m_trackerContext,
+ TestCaseTracking::NameAndLocationRef(
+ generatorName, lineInfo ) );
+ m_lastAssertionInfo.lineInfo = lineInfo;
+ return tracker;
+ }
+
+ IGeneratorTracker* RunContext::createGeneratorTracker(
+ StringRef generatorName,
+ SourceLineInfo lineInfo,
+ Generators::GeneratorBasePtr&& generator ) {
+
+ auto nameAndLoc = TestCaseTracking::NameAndLocation( static_cast<std::string>( generatorName ), lineInfo );
+ auto& currentTracker = m_trackerContext.currentTracker();
+ assert(
+ currentTracker.nameAndLocation() != nameAndLoc &&
+ "Trying to create tracker for a genreator that already has one" );
+
+ auto newTracker = Catch::Detail::make_unique<Generators::GeneratorTracker>(
+ CATCH_MOVE(nameAndLoc), m_trackerContext, ¤tTracker );
+ auto ret = newTracker.get();
+ currentTracker.addChild( CATCH_MOVE( newTracker ) );
+
+ ret->setGenerator( CATCH_MOVE( generator ) );
+ ret->open();
+ return ret;
+ }
+
+ bool RunContext::testForMissingAssertions(Counts& assertions) {
+ if (assertions.total() != 0)
+ return false;
+ if (!m_config->warnAboutMissingAssertions())
+ return false;
+ if (m_trackerContext.currentTracker().hasChildren())
+ return false;
+ m_totals.assertions.failed++;
+ assertions.failed++;
+ return true;
+ }
+
+ void RunContext::sectionEnded(SectionEndInfo&& endInfo) {
+ Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+ bool missingAssertions = testForMissingAssertions(assertions);
+
+ if (!m_activeSections.empty()) {
+ m_activeSections.back()->close();
+ m_activeSections.pop_back();
+ }
+
+ m_reporter->sectionEnded(SectionStats(CATCH_MOVE(endInfo.sectionInfo), assertions, endInfo.durationInSeconds, missingAssertions));
+ m_messages.clear();
+ m_messageScopes.clear();
+ }
+
+ void RunContext::sectionEndedEarly(SectionEndInfo&& endInfo) {
+ if ( m_unfinishedSections.empty() ) {
+ m_activeSections.back()->fail();
+ } else {
+ m_activeSections.back()->close();
+ }
+ m_activeSections.pop_back();
+
+ m_unfinishedSections.push_back(CATCH_MOVE(endInfo));
+ }
+
+ void RunContext::benchmarkPreparing( StringRef name ) {
+ m_reporter->benchmarkPreparing(name);
+ }
+ void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
+ m_reporter->benchmarkStarting( info );
+ }
+ void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
+ m_reporter->benchmarkEnded( stats );
+ }
+ void RunContext::benchmarkFailed( StringRef error ) {
+ m_reporter->benchmarkFailed( error );
+ }
+
+ void RunContext::pushScopedMessage(MessageInfo const & message) {
+ m_messages.push_back(message);
+ }
+
+ void RunContext::popScopedMessage(MessageInfo const & message) {
+ m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+ }
+
+ void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) {
+ m_messageScopes.emplace_back( CATCH_MOVE(builder) );
+ }
+
+ std::string RunContext::getCurrentTestName() const {
+ return m_activeTestCase
+ ? m_activeTestCase->getTestCaseInfo().name
+ : std::string();
+ }
+
+ const AssertionResult * RunContext::getLastResult() const {
+ return &(*m_lastResult);
+ }
+
+ void RunContext::exceptionEarlyReported() {
+ m_shouldReportUnexpected = false;
+ }
+
+ void RunContext::handleFatalErrorCondition( StringRef message ) {
+ // First notify reporter that bad things happened
+ m_reporter->fatalErrorEncountered(message);
+
+ // Don't rebuild the result -- the stringification itself can cause more fatal errors
+ // Instead, fake a result data.
+ AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
+ tempResult.message = static_cast<std::string>(message);
+ AssertionResult result(m_lastAssertionInfo, CATCH_MOVE(tempResult));
+
+ assertionEnded(CATCH_MOVE(result) );
+ resetAssertionInfo();
+
+ // Best effort cleanup for sections that have not been destructed yet
+ // Since this is a fatal error, we have not had and won't have the opportunity to destruct them properly
+ while (!m_activeSections.empty()) {
+ auto nl = m_activeSections.back()->nameAndLocation();
+ SectionEndInfo endInfo{ SectionInfo(CATCH_MOVE(nl.location), CATCH_MOVE(nl.name)), {}, 0.0 };
+ sectionEndedEarly(CATCH_MOVE(endInfo));
+ }
+ handleUnfinishedSections();
+
+ // Recreate section for test case (as we will lose the one that was in scope)
+ auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+ SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+
+ Counts assertions;
+ assertions.failed = 1;
+ SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false);
+ m_reporter->sectionEnded(testCaseSectionStats);
+
+ auto const& testInfo = m_activeTestCase->getTestCaseInfo();
+
+ Totals deltaTotals;
+ deltaTotals.testCases.failed = 1;
+ deltaTotals.assertions.failed = 1;
+ m_reporter->testCaseEnded(TestCaseStats(testInfo,
+ deltaTotals,
+ std::string(),
+ std::string(),
+ false));
+ m_totals.testCases.failed++;
+ m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+ }
+
+ bool RunContext::lastAssertionPassed() {
+ return m_lastAssertionPassed;
+ }
+
+ void RunContext::assertionPassed() {
+ m_lastAssertionPassed = true;
+ ++m_totals.assertions.passed;
+ resetAssertionInfo();
+ m_messageScopes.clear();
+ }
+
+ bool RunContext::aborting() const {
+ return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
+ }
+
+ void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
+ auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+ SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+ m_reporter->sectionStarting(testCaseSection);
+ Counts prevAssertions = m_totals.assertions;
+ double duration = 0;
+ m_shouldReportUnexpected = true;
+ m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
+
+ Timer timer;
+ CATCH_TRY {
+ if (m_reporter->getPreferences().shouldRedirectStdOut) {
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+ RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
+
+ timer.start();
+ invokeActiveTestCase();
+#else
+ OutputRedirect r(redirectedCout, redirectedCerr);
+ timer.start();
+ invokeActiveTestCase();
+#endif
+ } else {
+ timer.start();
+ invokeActiveTestCase();
+ }
+ duration = timer.getElapsedSeconds();
+ } CATCH_CATCH_ANON (TestFailureException&) {
+ // This just means the test was aborted due to failure
+ } CATCH_CATCH_ANON (TestSkipException&) {
+ // This just means the test was explicitly skipped
+ } CATCH_CATCH_ALL {
+ // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+ // are reported without translation at the point of origin.
+ if( m_shouldReportUnexpected ) {
+ AssertionReaction dummyReaction;
+ handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
+ }
+ }
+ Counts assertions = m_totals.assertions - prevAssertions;
+ bool missingAssertions = testForMissingAssertions(assertions);
+
+ m_testCaseTracker->close();
+ handleUnfinishedSections();
+ m_messages.clear();
+ m_messageScopes.clear();
+
+ SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions);
+ m_reporter->sectionEnded(testCaseSectionStats);
+ }
+
+ void RunContext::invokeActiveTestCase() {
+ // We need to engage a handler for signals/structured exceptions
+ // before running the tests themselves, or the binary can crash
+ // without failed test being reported.
+ FatalConditionHandlerGuard _(&m_fatalConditionhandler);
+ // We keep having issue where some compilers warn about an unused
+ // variable, even though the type has non-trivial constructor and
+ // destructor. This is annoying and ugly, but it makes them stfu.
+ (void)_;
+
+ m_activeTestCase->invoke();
+ }
+
+ void RunContext::handleUnfinishedSections() {
+ // If sections ended prematurely due to an exception we stored their
+ // infos here so we can tear them down outside the unwind process.
+ for (auto it = m_unfinishedSections.rbegin(),
+ itEnd = m_unfinishedSections.rend();
+ it != itEnd;
+ ++it)
+ sectionEnded(CATCH_MOVE(*it));
+ m_unfinishedSections.clear();
+ }
+
+ void RunContext::handleExpr(
+ AssertionInfo const& info,
+ ITransientExpression const& expr,
+ AssertionReaction& reaction
+ ) {
+ bool negated = isFalseTest( info.resultDisposition );
+ bool result = expr.getResult() != negated;
+
+ if( result ) {
+ if (!m_includeSuccessfulResults) {
+ assertionPassed();
+ }
+ else {
+ reportExpr(info, ResultWas::Ok, &expr, negated);
+ }
+ }
+ else {
+ reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
+ populateReaction( reaction );
+ }
+ resetAssertionInfo();
+ }
+ void RunContext::reportExpr(
+ AssertionInfo const &info,
+ ResultWas::OfType resultType,
+ ITransientExpression const *expr,
+ bool negated ) {
+
+ m_lastAssertionInfo = info;
+ AssertionResultData data( resultType, LazyExpression( negated ) );
+
+ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
+ assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
+
+ assertionEnded( CATCH_MOVE(assertionResult) );
+ }
+
+ void RunContext::handleMessage(
+ AssertionInfo const& info,
+ ResultWas::OfType resultType,
+ StringRef message,
+ AssertionReaction& reaction
+ ) {
+ m_lastAssertionInfo = info;
+
+ AssertionResultData data( resultType, LazyExpression( false ) );
+ data.message = static_cast<std::string>(message);
+ AssertionResult assertionResult{ m_lastAssertionInfo,
+ CATCH_MOVE( data ) };
+
+ const auto isOk = assertionResult.isOk();
+ assertionEnded( CATCH_MOVE(assertionResult) );
+ if ( !isOk ) {
+ populateReaction( reaction );
+ } else if ( resultType == ResultWas::ExplicitSkip ) {
+ // TODO: Need to handle this explicitly, as ExplicitSkip is
+ // considered "OK"
+ reaction.shouldSkip = true;
+ }
+ resetAssertionInfo();
+ }
+ void RunContext::handleUnexpectedExceptionNotThrown(
+ AssertionInfo const& info,
+ AssertionReaction& reaction
+ ) {
+ handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
+ }
+
+ void RunContext::handleUnexpectedInflightException(
+ AssertionInfo const& info,
+ std::string&& message,
+ AssertionReaction& reaction
+ ) {
+ m_lastAssertionInfo = info;
+
+ AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+ data.message = CATCH_MOVE(message);
+ AssertionResult assertionResult{ info, CATCH_MOVE(data) };
+ assertionEnded( CATCH_MOVE(assertionResult) );
+ populateReaction( reaction );
+ resetAssertionInfo();
+ }
+
+ void RunContext::populateReaction( AssertionReaction& reaction ) {
+ reaction.shouldDebugBreak = m_config->shouldDebugBreak();
+ reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
+ }
+
+ void RunContext::handleIncomplete(
+ AssertionInfo const& info
+ ) {
+ using namespace std::string_literals;
+ m_lastAssertionInfo = info;
+
+ AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+ data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"s;
+ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
+ assertionEnded( CATCH_MOVE(assertionResult) );
+ resetAssertionInfo();
+ }
+ void RunContext::handleNonExpr(
+ AssertionInfo const &info,
+ ResultWas::OfType resultType,
+ AssertionReaction &reaction
+ ) {
+ m_lastAssertionInfo = info;
+
+ AssertionResultData data( resultType, LazyExpression( false ) );
+ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
+
+ const auto isOk = assertionResult.isOk();
+ assertionEnded( CATCH_MOVE(assertionResult) );
+ if ( !isOk ) { populateReaction( reaction ); }
+ resetAssertionInfo();
+ }
+
+
+ IResultCapture& getResultCapture() {
+ if (auto* capture = getCurrentContext().getResultCapture())
+ return *capture;
+ else
+ CATCH_INTERNAL_ERROR("No result capture instance");
+ }
+
+ void seedRng(IConfig const& config) {
+ sharedRng().seed(config.rngSeed());
+ }
+
+ unsigned int rngSeed() {
+ return getCurrentContext().getConfig()->rngSeed();
+ }
+
+}
+
+
+
+namespace Catch {
+
+ Section::Section( SectionInfo&& info ):
+ m_info( CATCH_MOVE( info ) ),
+ m_sectionIncluded(
+ getResultCapture().sectionStarted( m_info.name, m_info.lineInfo, m_assertions ) ) {
+ // Non-"included" sections will not use the timing information
+ // anyway, so don't bother with the potential syscall.
+ if (m_sectionIncluded) {
+ m_timer.start();
+ }
+ }
+
+ Section::Section( SourceLineInfo const& _lineInfo,
+ StringRef _name,
+ const char* const ):
+ m_info( { "invalid", static_cast<std::size_t>( -1 ) }, std::string{} ),
+ m_sectionIncluded(
+ getResultCapture().sectionStarted( _name, _lineInfo, m_assertions ) ) {
+ // We delay initialization the SectionInfo member until we know
+ // this section needs it, so we avoid allocating std::string for name.
+ // We also delay timer start to avoid the potential syscall unless we
+ // will actually use the result.
+ if ( m_sectionIncluded ) {
+ m_info.name = static_cast<std::string>( _name );
+ m_info.lineInfo = _lineInfo;
+ m_timer.start();
+ }
+ }
+
+ Section::~Section() {
+ if( m_sectionIncluded ) {
+ SectionEndInfo endInfo{ CATCH_MOVE(m_info), m_assertions, m_timer.getElapsedSeconds() };
+ if ( uncaught_exceptions() ) {
+ getResultCapture().sectionEndedEarly( CATCH_MOVE(endInfo) );
+ } else {
+ getResultCapture().sectionEnded( CATCH_MOVE( endInfo ) );
+ }
+ }
+ }
+
+ // This indicates whether the section should be executed or not
+ Section::operator bool() const {
+ return m_sectionIncluded;
+ }
+
+
+} // end namespace Catch
+
+
+
+#include <vector>
+
+namespace Catch {
+
+ namespace {
+ static auto getSingletons() -> std::vector<ISingleton*>*& {
+ static std::vector<ISingleton*>* g_singletons = nullptr;
+ if( !g_singletons )
+ g_singletons = new std::vector<ISingleton*>();
+ return g_singletons;
+ }
+ }
+
+ ISingleton::~ISingleton() = default;
+
+ void addSingleton(ISingleton* singleton ) {
+ getSingletons()->push_back( singleton );
+ }
+ void cleanupSingletons() {
+ auto& singletons = getSingletons();
+ for( auto singleton : *singletons )
+ delete singleton;
+ delete singletons;
+ singletons = nullptr;
+ }
+
+} // namespace Catch
+
+
+
+#include <cstring>
+#include <ostream>
+
+namespace Catch {
+
+ bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
+ return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+ }
+ bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
+ // We can assume that the same file will usually have the same pointer.
+ // Thus, if the pointers are the same, there is no point in calling the strcmp
+ return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
+ }
+
+ std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+ os << info.file << '(' << info.line << ')';
+#else
+ os << info.file << ':' << info.line;
+#endif
+ return os;
+ }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+ void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
+ CATCH_TRY {
+ m_exceptions.push_back(exception);
+ } CATCH_CATCH_ALL {
+ // If we run out of memory during start-up there's really not a lot more we can do about it
+ std::terminate();
+ }
+ }
+
+ std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
+ return m_exceptions;
+ }
+#endif
+
+} // end namespace Catch
+
+
+
+
+
+#include <iostream>
+
+namespace Catch {
+
+// If you #define this you must implement these functions
+#if !defined( CATCH_CONFIG_NOSTDOUT )
+ std::ostream& cout() { return std::cout; }
+ std::ostream& cerr() { return std::cerr; }
+ std::ostream& clog() { return std::clog; }
+#endif
+
+} // namespace Catch
+
+
+
+#include <ostream>
+#include <cstring>
+#include <cctype>
+#include <vector>
+
+namespace Catch {
+
+ bool startsWith( std::string const& s, std::string const& prefix ) {
+ return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+ }
+ bool startsWith( StringRef s, char prefix ) {
+ return !s.empty() && s[0] == prefix;
+ }
+ bool endsWith( std::string const& s, std::string const& suffix ) {
+ return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+ }
+ bool endsWith( std::string const& s, char suffix ) {
+ return !s.empty() && s[s.size()-1] == suffix;
+ }
+ bool contains( std::string const& s, std::string const& infix ) {
+ return s.find( infix ) != std::string::npos;
+ }
+ void toLowerInPlace( std::string& s ) {
+ for ( char& c : s ) {
+ c = toLower( c );
+ }
+ }
+ std::string toLower( std::string const& s ) {
+ std::string lc = s;
+ toLowerInPlace( lc );
+ return lc;
+ }
+ char toLower(char c) {
+ return static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+ }
+
+ std::string trim( std::string const& str ) {
+ static char const* whitespaceChars = "\n\r\t ";
+ std::string::size_type start = str.find_first_not_of( whitespaceChars );
+ std::string::size_type end = str.find_last_not_of( whitespaceChars );
+
+ return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
+ }
+
+ StringRef trim(StringRef ref) {
+ const auto is_ws = [](char c) {
+ return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+ };
+ size_t real_begin = 0;
+ while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
+ size_t real_end = ref.size();
+ while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
+
+ return ref.substr(real_begin, real_end - real_begin);
+ }
+
+ bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+ std::size_t i = str.find( replaceThis );
+ if (i == std::string::npos) {
+ return false;
+ }
+ std::size_t copyBegin = 0;
+ std::string origStr = CATCH_MOVE(str);
+ str.clear();
+ // There is at least one replacement, so reserve with the best guess
+ // we can make without actually counting the number of occurences.
+ str.reserve(origStr.size() - replaceThis.size() + withThis.size());
+ do {
+ str.append(origStr, copyBegin, i-copyBegin );
+ str += withThis;
+ copyBegin = i + replaceThis.size();
+ if( copyBegin < origStr.size() )
+ i = origStr.find( replaceThis, copyBegin );
+ else
+ i = std::string::npos;
+ } while( i != std::string::npos );
+ if ( copyBegin < origStr.size() ) {
+ str.append(origStr, copyBegin, origStr.size() );
+ }
+ return true;
+ }
+
+ std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
+ std::vector<StringRef> subStrings;
+ std::size_t start = 0;
+ for(std::size_t pos = 0; pos < str.size(); ++pos ) {
+ if( str[pos] == delimiter ) {
+ if( pos - start > 1 )
+ subStrings.push_back( str.substr( start, pos-start ) );
+ start = pos+1;
+ }
+ }
+ if( start < str.size() )
+ subStrings.push_back( str.substr( start, str.size()-start ) );
+ return subStrings;
+ }
+
+ std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+ os << pluraliser.m_count << ' ' << pluraliser.m_label;
+ if( pluraliser.m_count != 1 )
+ os << 's';
+ return os;
+ }
+
+}
+
+
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cstdint>
+
+namespace Catch {
+ StringRef::StringRef( char const* rawChars ) noexcept
+ : StringRef( rawChars, std::strlen(rawChars) )
+ {}
+
+
+ bool StringRef::operator<(StringRef rhs) const noexcept {
+ if (m_size < rhs.m_size) {
+ return strncmp(m_start, rhs.m_start, m_size) <= 0;
+ }
+ return strncmp(m_start, rhs.m_start, rhs.m_size) < 0;
+ }
+
+ int StringRef::compare( StringRef rhs ) const {
+ auto cmpResult =
+ strncmp( m_start, rhs.m_start, std::min( m_size, rhs.m_size ) );
+
+ // This means that strncmp found a difference before the strings
+ // ended, and we can return it directly
+ if ( cmpResult != 0 ) {
+ return cmpResult;
+ }
+
+ // If strings are equal up to length, then their comparison results on
+ // their size
+ if ( m_size < rhs.m_size ) {
+ return -1;
+ } else if ( m_size > rhs.m_size ) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+
+ auto operator << ( std::ostream& os, StringRef str ) -> std::ostream& {
+ return os.write(str.data(), static_cast<std::streamsize>(str.size()));
+ }
+
+ std::string operator+(StringRef lhs, StringRef rhs) {
+ std::string ret;
+ ret.reserve(lhs.size() + rhs.size());
+ ret += lhs;
+ ret += rhs;
+ return ret;
+ }
+
+ auto operator+=( std::string& lhs, StringRef rhs ) -> std::string& {
+ lhs.append(rhs.data(), rhs.size());
+ return lhs;
+ }
+
+} // namespace Catch
+
+
+
+namespace Catch {
+
+ TagAliasRegistry::~TagAliasRegistry() = default;
+
+ TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
+ auto it = m_registry.find( alias );
+ if( it != m_registry.end() )
+ return &(it->second);
+ else
+ return nullptr;
+ }
+
+ std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+ std::string expandedTestSpec = unexpandedTestSpec;
+ for( auto const& registryKvp : m_registry ) {
+ std::size_t pos = expandedTestSpec.find( registryKvp.first );
+ if( pos != std::string::npos ) {
+ expandedTestSpec = expandedTestSpec.substr( 0, pos ) +
+ registryKvp.second.tag +
+ expandedTestSpec.substr( pos + registryKvp.first.size() );
+ }
+ }
+ return expandedTestSpec;
+ }
+
+ void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+ CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
+ "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
+
+ CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
+ "error: tag alias, '" << alias << "' already registered.\n"
+ << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
+ << "\tRedefined at: " << lineInfo );
+ }
+
+ ITagAliasRegistry::~ITagAliasRegistry() = default;
+
+ ITagAliasRegistry const& ITagAliasRegistry::get() {
+ return getRegistryHub().getTagAliasRegistry();
+ }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+ TestCaseInfoHasher::TestCaseInfoHasher( hash_t seed ): m_seed( seed ) {}
+
+ uint32_t TestCaseInfoHasher::operator()( TestCaseInfo const& t ) const {
+ // FNV-1a hash algorithm that is designed for uniqueness:
+ const hash_t prime = 1099511628211u;
+ hash_t hash = 14695981039346656037u;
+ for ( const char c : t.name ) {
+ hash ^= c;
+ hash *= prime;
+ }
+ for ( const char c : t.className ) {
+ hash ^= c;
+ hash *= prime;
+ }
+ for ( const Tag& tag : t.tags ) {
+ for ( const char c : tag.original ) {
+ hash ^= c;
+ hash *= prime;
+ }
+ }
+ hash ^= m_seed;
+ hash *= prime;
+ const uint32_t low{ static_cast<uint32_t>( hash ) };
+ const uint32_t high{ static_cast<uint32_t>( hash >> 32 ) };
+ return low * high;
+ }
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+#include <set>
+
+namespace Catch {
+
+ namespace {
+ static void enforceNoDuplicateTestCases(
+ std::vector<TestCaseHandle> const& tests ) {
+ auto testInfoCmp = []( TestCaseInfo const* lhs,
+ TestCaseInfo const* rhs ) {
+ return *lhs < *rhs;
+ };
+ std::set<TestCaseInfo const*, decltype( testInfoCmp )&> seenTests(
+ testInfoCmp );
+ for ( auto const& test : tests ) {
+ const auto infoPtr = &test.getTestCaseInfo();
+ const auto prev = seenTests.insert( infoPtr );
+ CATCH_ENFORCE( prev.second,
+ "error: test case \""
+ << infoPtr->name << "\", with tags \""
+ << infoPtr->tagsAsString()
+ << "\" already defined.\n"
+ << "\tFirst seen at "
+ << ( *prev.first )->lineInfo << "\n"
+ << "\tRedefined at " << infoPtr->lineInfo );
+ }
+ }
+
+ static bool matchTest( TestCaseHandle const& testCase,
+ TestSpec const& testSpec,
+ IConfig const& config ) {
+ return testSpec.matches( testCase.getTestCaseInfo() ) &&
+ isThrowSafe( testCase, config );
+ }
+
+ } // end unnamed namespace
+
+ std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases ) {
+ switch (config.runOrder()) {
+ case TestRunOrder::Declared:
+ return unsortedTestCases;
+
+ case TestRunOrder::LexicographicallySorted: {
+ std::vector<TestCaseHandle> sorted = unsortedTestCases;
+ std::sort(
+ sorted.begin(),
+ sorted.end(),
+ []( TestCaseHandle const& lhs, TestCaseHandle const& rhs ) {
+ return lhs.getTestCaseInfo() < rhs.getTestCaseInfo();
+ }
+ );
+ return sorted;
+ }
+ case TestRunOrder::Randomized: {
+ using TestWithHash = std::pair<TestCaseInfoHasher::hash_t, TestCaseHandle>;
+
+ TestCaseInfoHasher h{ config.rngSeed() };
+ std::vector<TestWithHash> indexed_tests;
+ indexed_tests.reserve(unsortedTestCases.size());
+
+ for (auto const& handle : unsortedTestCases) {
+ indexed_tests.emplace_back(h(handle.getTestCaseInfo()), handle);
+ }
+
+ std::sort( indexed_tests.begin(),
+ indexed_tests.end(),
+ []( TestWithHash const& lhs, TestWithHash const& rhs ) {
+ if ( lhs.first == rhs.first ) {
+ return lhs.second.getTestCaseInfo() <
+ rhs.second.getTestCaseInfo();
+ }
+ return lhs.first < rhs.first;
+ } );
+
+ std::vector<TestCaseHandle> randomized;
+ randomized.reserve(indexed_tests.size());
+
+ for (auto const& indexed : indexed_tests) {
+ randomized.push_back(indexed.second);
+ }
+
+ return randomized;
+ }
+ }
+
+ CATCH_INTERNAL_ERROR("Unknown test order value!");
+ }
+
+ bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config ) {
+ return !testCase.getTestCaseInfo().throws() || config.allowThrows();
+ }
+
+ std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+ std::vector<TestCaseHandle> filtered;
+ filtered.reserve( testCases.size() );
+ for (auto const& testCase : testCases) {
+ if ((!testSpec.hasFilters() && !testCase.getTestCaseInfo().isHidden()) ||
+ (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+ filtered.push_back(testCase);
+ }
+ }
+ return createShard(filtered, config.shardCount(), config.shardIndex());
+ }
+ std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config ) {
+ return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+ }
+
+ TestRegistry::~TestRegistry() = default;
+
+ void TestRegistry::registerTest(Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker) {
+ m_handles.emplace_back(testInfo.get(), testInvoker.get());
+ m_viewed_test_infos.push_back(testInfo.get());
+ m_owned_test_infos.push_back(CATCH_MOVE(testInfo));
+ m_invokers.push_back(CATCH_MOVE(testInvoker));
+ }
+
+ std::vector<TestCaseInfo*> const& TestRegistry::getAllInfos() const {
+ return m_viewed_test_infos;
+ }
+
+ std::vector<TestCaseHandle> const& TestRegistry::getAllTests() const {
+ return m_handles;
+ }
+ std::vector<TestCaseHandle> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
+ if( m_sortedFunctions.empty() )
+ enforceNoDuplicateTestCases( m_handles );
+
+ if( m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+ m_sortedFunctions = sortTests( config, m_handles );
+ m_currentSortOrder = config.runOrder();
+ }
+ return m_sortedFunctions;
+ }
+
+} // end namespace Catch
+
+
+
+
+#include <algorithm>
+#include <cassert>
+
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+namespace Catch {
+namespace TestCaseTracking {
+
+ NameAndLocation::NameAndLocation( std::string&& _name, SourceLineInfo const& _location )
+ : name( CATCH_MOVE(_name) ),
+ location( _location )
+ {}
+
+
+ ITracker::~ITracker() = default;
+
+ void ITracker::markAsNeedingAnotherRun() {
+ m_runState = NeedsAnotherRun;
+ }
+
+ void ITracker::addChild( ITrackerPtr&& child ) {
+ m_children.push_back( CATCH_MOVE(child) );
+ }
+
+ ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLocation ) {
+ auto it = std::find_if(
+ m_children.begin(),
+ m_children.end(),
+ [&nameAndLocation]( ITrackerPtr const& tracker ) {
+ auto const& tnameAndLoc = tracker->nameAndLocation();
+ if ( tnameAndLoc.location.line !=
+ nameAndLocation.location.line ) {
+ return false;
+ }
+ return tnameAndLoc == nameAndLocation;
+ } );
+ return ( it != m_children.end() ) ? it->get() : nullptr;
+ }
+
+ bool ITracker::isSectionTracker() const { return false; }
+ bool ITracker::isGeneratorTracker() const { return false; }
+
+ bool ITracker::isOpen() const {
+ return m_runState != NotStarted && !isComplete();
+ }
+
+ bool ITracker::hasStarted() const { return m_runState != NotStarted; }
+
+ void ITracker::openChild() {
+ if (m_runState != ExecutingChildren) {
+ m_runState = ExecutingChildren;
+ if (m_parent) {
+ m_parent->openChild();
+ }
+ }
+ }
+
+ ITracker& TrackerContext::startRun() {
+ using namespace std::string_literals;
+ m_rootTracker = Catch::Detail::make_unique<SectionTracker>(
+ NameAndLocation( "{root}"s, CATCH_INTERNAL_LINEINFO ),
+ *this,
+ nullptr );
+ m_currentTracker = nullptr;
+ m_runState = Executing;
+ return *m_rootTracker;
+ }
+
+ void TrackerContext::completeCycle() {
+ m_runState = CompletedCycle;
+ }
+
+ bool TrackerContext::completedCycle() const {
+ return m_runState == CompletedCycle;
+ }
+ void TrackerContext::setCurrentTracker( ITracker* tracker ) {
+ m_currentTracker = tracker;
+ }
+
+
+ TrackerBase::TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
+ ITracker(CATCH_MOVE(nameAndLocation), parent),
+ m_ctx( ctx )
+ {}
+
+ bool TrackerBase::isComplete() const {
+ return m_runState == CompletedSuccessfully || m_runState == Failed;
+ }
+
+ void TrackerBase::open() {
+ m_runState = Executing;
+ moveToThis();
+ if( m_parent )
+ m_parent->openChild();
+ }
+
+ void TrackerBase::close() {
+
+ // Close any still open children (e.g. generators)
+ while( &m_ctx.currentTracker() != this )
+ m_ctx.currentTracker().close();
+
+ switch( m_runState ) {
+ case NeedsAnotherRun:
+ break;
+
+ case Executing:
+ m_runState = CompletedSuccessfully;
+ break;
+ case ExecutingChildren:
+ if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
+ m_runState = CompletedSuccessfully;
+ break;
+
+ case NotStarted:
+ case CompletedSuccessfully:
+ case Failed:
+ CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
+
+ default:
+ CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
+ }
+ moveToParent();
+ m_ctx.completeCycle();
+ }
+ void TrackerBase::fail() {
+ m_runState = Failed;
+ if( m_parent )
+ m_parent->markAsNeedingAnotherRun();
+ moveToParent();
+ m_ctx.completeCycle();
+ }
+
+ void TrackerBase::moveToParent() {
+ assert( m_parent );
+ m_ctx.setCurrentTracker( m_parent );
+ }
+ void TrackerBase::moveToThis() {
+ m_ctx.setCurrentTracker( this );
+ }
+
+ SectionTracker::SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+ : TrackerBase( CATCH_MOVE(nameAndLocation), ctx, parent ),
+ m_trimmed_name(trim(StringRef(ITracker::nameAndLocation().name)))
+ {
+ if( parent ) {
+ while ( !parent->isSectionTracker() ) {
+ parent = parent->parent();
+ }
+
+ SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+ addNextFilters( parentSection.m_filters );
+ }
+ }
+
+ bool SectionTracker::isComplete() const {
+ bool complete = true;
+
+ if (m_filters.empty()
+ || m_filters[0].empty()
+ || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
+ complete = TrackerBase::isComplete();
+ }
+ return complete;
+ }
+
+ bool SectionTracker::isSectionTracker() const { return true; }
+
+ SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation ) {
+ SectionTracker* tracker;
+
+ ITracker& currentTracker = ctx.currentTracker();
+ if ( ITracker* childTracker =
+ currentTracker.findChild( nameAndLocation ) ) {
+ assert( childTracker );
+ assert( childTracker->isSectionTracker() );
+ tracker = static_cast<SectionTracker*>( childTracker );
+ } else {
+ auto newTracker = Catch::Detail::make_unique<SectionTracker>(
+ NameAndLocation{ static_cast<std::string>(nameAndLocation.name),
+ nameAndLocation.location },
+ ctx,
+ ¤tTracker );
+ tracker = newTracker.get();
+ currentTracker.addChild( CATCH_MOVE( newTracker ) );
+ }
+
+ if ( !ctx.completedCycle() ) {
+ tracker->tryOpen();
+ }
+
+ return *tracker;
+ }
+
+ void SectionTracker::tryOpen() {
+ if( !isComplete() )
+ open();
+ }
+
+ void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
+ if( !filters.empty() ) {
+ m_filters.reserve( m_filters.size() + filters.size() + 2 );
+ m_filters.emplace_back(StringRef{}); // Root - should never be consulted
+ m_filters.emplace_back(StringRef{}); // Test Case - not a section filter
+ m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+ }
+ }
+ void SectionTracker::addNextFilters( std::vector<StringRef> const& filters ) {
+ if( filters.size() > 1 )
+ m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
+ }
+
+ StringRef SectionTracker::trimmedName() const {
+ return m_trimmed_name;
+ }
+
+} // namespace TestCaseTracking
+
+} // namespace Catch
+
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+
+
+
+
+namespace Catch {
+
+ void throw_test_failure_exception() {
+#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
+ throw TestFailureException{};
+#else
+ CATCH_ERROR( "Test failure requires aborting test!" );
+#endif
+ }
+
+ void throw_test_skip_exception() {
+#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
+ throw Catch::TestSkipException();
+#else
+ CATCH_ERROR( "Explicitly skipping tests during runtime requires exceptions" );
+#endif
+ }
+
+} // namespace Catch
+
+
+
+#include <algorithm>
+#include <iterator>
+
+namespace Catch {
+ ITestInvoker::~ITestInvoker() = default;
+
+ namespace {
+ static StringRef extractClassName( StringRef classOrMethodName ) {
+ if ( !startsWith( classOrMethodName, '&' ) ) {
+ return classOrMethodName;
+ }
+
+ // Remove the leading '&' to avoid having to special case it later
+ const auto methodName =
+ classOrMethodName.substr( 1, classOrMethodName.size() );
+
+ auto reverseStart = std::make_reverse_iterator( methodName.end() );
+ auto reverseEnd = std::make_reverse_iterator( methodName.begin() );
+
+ // We make a simplifying assumption that ":" is only present
+ // in the input as part of "::" from C++ typenames (this is
+ // relatively safe assumption because the input is generated
+ // as stringification of type through preprocessor).
+ auto lastColons = std::find( reverseStart, reverseEnd, ':' ) + 1;
+ auto secondLastColons =
+ std::find( lastColons + 1, reverseEnd, ':' );
+
+ auto const startIdx = reverseEnd - secondLastColons;
+ auto const classNameSize = secondLastColons - lastColons - 1;
+
+ return methodName.substr(
+ static_cast<std::size_t>( startIdx ),
+ static_cast<std::size_t>( classNameSize ) );
+ }
+
+ class TestInvokerAsFunction final : public ITestInvoker {
+ using TestType = void ( * )();
+ TestType m_testAsFunction;
+
+ public:
+ TestInvokerAsFunction( TestType testAsFunction ) noexcept:
+ m_testAsFunction( testAsFunction ) {}
+
+ void invoke() const override { m_testAsFunction(); }
+ };
+
+ } // namespace
+
+ Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() ) {
+ return Detail::make_unique<TestInvokerAsFunction>( testAsFunction );
+ }
+
+ AutoReg::AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept {
+ CATCH_TRY {
+ getMutableRegistryHub()
+ .registerTest(
+ makeTestCaseInfo(
+ extractClassName( classOrMethod ),
+ nameAndTags,
+ lineInfo),
+ CATCH_MOVE(invoker)
+ );
+ } CATCH_CATCH_ALL {
+ // Do not throw when constructing global objects, instead register the exception to be processed later
+ getMutableRegistryHub().registerStartupException();
+ }
+ }
+}
+
+
+
+
+
+namespace Catch {
+
+ TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+
+ TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
+ m_mode = None;
+ m_exclusion = false;
+ m_arg = m_tagAliases->expandAliases( arg );
+ m_escapeChars.clear();
+ m_substring.reserve(m_arg.size());
+ m_patternName.reserve(m_arg.size());
+ m_realPatternPos = 0;
+
+ for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+ //if visitChar fails
+ if( !visitChar( m_arg[m_pos] ) ){
+ m_testSpec.m_invalidSpecs.push_back(arg);
+ break;
+ }
+ endMode();
+ return *this;
+ }
+ TestSpec TestSpecParser::testSpec() {
+ addFilter();
+ return CATCH_MOVE(m_testSpec);
+ }
+ bool TestSpecParser::visitChar( char c ) {
+ if( (m_mode != EscapedName) && (c == '\\') ) {
+ escape();
+ addCharToPattern(c);
+ return true;
+ }else if((m_mode != EscapedName) && (c == ',') ) {
+ return separate();
+ }
+
+ switch( m_mode ) {
+ case None:
+ if( processNoneChar( c ) )
+ return true;
+ break;
+ case Name:
+ processNameChar( c );
+ break;
+ case EscapedName:
+ endMode();
+ addCharToPattern(c);
+ return true;
+ default:
+ case Tag:
+ case QuotedName:
+ if( processOtherChar( c ) )
+ return true;
+ break;
+ }
+
+ m_substring += c;
+ if( !isControlChar( c ) ) {
+ m_patternName += c;
+ m_realPatternPos++;
+ }
+ return true;
+ }
+ // Two of the processing methods return true to signal the caller to return
+ // without adding the given character to the current pattern strings
+ bool TestSpecParser::processNoneChar( char c ) {
+ switch( c ) {
+ case ' ':
+ return true;
+ case '~':
+ m_exclusion = true;
+ return false;
+ case '[':
+ startNewMode( Tag );
+ return false;
+ case '"':
+ startNewMode( QuotedName );
+ return false;
+ default:
+ startNewMode( Name );
+ return false;
+ }
+ }
+ void TestSpecParser::processNameChar( char c ) {
+ if( c == '[' ) {
+ if( m_substring == "exclude:" )
+ m_exclusion = true;
+ else
+ endMode();
+ startNewMode( Tag );
+ }
+ }
+ bool TestSpecParser::processOtherChar( char c ) {
+ if( !isControlChar( c ) )
+ return false;
+ m_substring += c;
+ endMode();
+ return true;
+ }
+ void TestSpecParser::startNewMode( Mode mode ) {
+ m_mode = mode;
+ }
+ void TestSpecParser::endMode() {
+ switch( m_mode ) {
+ case Name:
+ case QuotedName:
+ return addNamePattern();
+ case Tag:
+ return addTagPattern();
+ case EscapedName:
+ revertBackToLastMode();
+ return;
+ case None:
+ default:
+ return startNewMode( None );
+ }
+ }
+ void TestSpecParser::escape() {
+ saveLastMode();
+ m_mode = EscapedName;
+ m_escapeChars.push_back(m_realPatternPos);
+ }
+ bool TestSpecParser::isControlChar( char c ) const {
+ switch( m_mode ) {
+ default:
+ return false;
+ case None:
+ return c == '~';
+ case Name:
+ return c == '[';
+ case EscapedName:
+ return true;
+ case QuotedName:
+ return c == '"';
+ case Tag:
+ return c == '[' || c == ']';
+ }
+ }
+
+ void TestSpecParser::addFilter() {
+ if( !m_currentFilter.m_required.empty() || !m_currentFilter.m_forbidden.empty() ) {
+ m_testSpec.m_filters.push_back( CATCH_MOVE(m_currentFilter) );
+ m_currentFilter = TestSpec::Filter();
+ }
+ }
+
+ void TestSpecParser::saveLastMode() {
+ lastMode = m_mode;
+ }
+
+ void TestSpecParser::revertBackToLastMode() {
+ m_mode = lastMode;
+ }
+
+ bool TestSpecParser::separate() {
+ if( (m_mode==QuotedName) || (m_mode==Tag) ){
+ //invalid argument, signal failure to previous scope.
+ m_mode = None;
+ m_pos = m_arg.size();
+ m_substring.clear();
+ m_patternName.clear();
+ m_realPatternPos = 0;
+ return false;
+ }
+ endMode();
+ addFilter();
+ return true; //success
+ }
+
+ std::string TestSpecParser::preprocessPattern() {
+ std::string token = m_patternName;
+ for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+ token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+ m_escapeChars.clear();
+ if (startsWith(token, "exclude:")) {
+ m_exclusion = true;
+ token = token.substr(8);
+ }
+
+ m_patternName.clear();
+ m_realPatternPos = 0;
+
+ return token;
+ }
+
+ void TestSpecParser::addNamePattern() {
+ auto token = preprocessPattern();
+
+ if (!token.empty()) {
+ if (m_exclusion) {
+ m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
+ } else {
+ m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
+ }
+ }
+ m_substring.clear();
+ m_exclusion = false;
+ m_mode = None;
+ }
+
+ void TestSpecParser::addTagPattern() {
+ auto token = preprocessPattern();
+
+ if (!token.empty()) {
+ // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
+ // we have to create a separate hide tag and shorten the real one
+ if (token.size() > 1 && token[0] == '.') {
+ token.erase(token.begin());
+ if (m_exclusion) {
+ m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
+ } else {
+ m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
+ }
+ }
+ if (m_exclusion) {
+ m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
+ } else {
+ m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
+ }
+ }
+ m_substring.clear();
+ m_exclusion = false;
+ m_mode = None;
+ }
+
+} // namespace Catch
+
+
+
+#include <algorithm>
+#include <cstring>
+#include <ostream>
+
+namespace {
+ bool isWhitespace( char c ) {
+ return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+ }
+
+ bool isBreakableBefore( char c ) {
+ static const char chars[] = "[({<|";
+ return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
+ }
+
+ bool isBreakableAfter( char c ) {
+ static const char chars[] = "])}>.,:;*+-=&/\\";
+ return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
+ }
+
+} // namespace
+
+namespace Catch {
+ namespace TextFlow {
+ void AnsiSkippingString::preprocessString() {
+ for ( auto it = m_string.begin(); it != m_string.end(); ) {
+ // try to read through an ansi sequence
+ while ( it != m_string.end() && *it == '\033' &&
+ it + 1 != m_string.end() && *( it + 1 ) == '[' ) {
+ auto cursor = it + 2;
+ while ( cursor != m_string.end() &&
+ ( isdigit( *cursor ) || *cursor == ';' ) ) {
+ ++cursor;
+ }
+ if ( cursor == m_string.end() || *cursor != 'm' ) {
+ break;
+ }
+ // 'm' -> 0xff
+ *cursor = AnsiSkippingString::sentinel;
+ // if we've read an ansi sequence, set the iterator and
+ // return to the top of the loop
+ it = cursor + 1;
+ }
+ if ( it != m_string.end() ) {
+ ++m_size;
+ ++it;
+ }
+ }
+ }
+
+ AnsiSkippingString::AnsiSkippingString( std::string const& text ):
+ m_string( text ) {
+ preprocessString();
+ }
+
+ AnsiSkippingString::AnsiSkippingString( std::string&& text ):
+ m_string( CATCH_MOVE( text ) ) {
+ preprocessString();
+ }
+
+ AnsiSkippingString::const_iterator AnsiSkippingString::begin() const {
+ return const_iterator( m_string );
+ }
+
+ AnsiSkippingString::const_iterator AnsiSkippingString::end() const {
+ return const_iterator( m_string, const_iterator::EndTag{} );
+ }
+
+ std::string AnsiSkippingString::substring( const_iterator begin,
+ const_iterator end ) const {
+ // There's one caveat here to an otherwise simple substring: when
+ // making a begin iterator we might have skipped ansi sequences at
+ // the start. If `begin` here is a begin iterator, skipped over
+ // initial ansi sequences, we'll use the true beginning of the
+ // string. Lastly: We need to transform any chars we replaced with
+ // 0xff back to 'm'
+ auto str = std::string( begin == this->begin() ? m_string.begin()
+ : begin.m_it,
+ end.m_it );
+ std::transform( str.begin(), str.end(), str.begin(), []( char c ) {
+ return c == AnsiSkippingString::sentinel ? 'm' : c;
+ } );
+ return str;
+ }
+
+ void AnsiSkippingString::const_iterator::tryParseAnsiEscapes() {
+ // check if we've landed on an ansi sequence, and if so read through
+ // it
+ while ( m_it != m_string->end() && *m_it == '\033' &&
+ m_it + 1 != m_string->end() && *( m_it + 1 ) == '[' ) {
+ auto cursor = m_it + 2;
+ while ( cursor != m_string->end() &&
+ ( isdigit( *cursor ) || *cursor == ';' ) ) {
+ ++cursor;
+ }
+ if ( cursor == m_string->end() ||
+ *cursor != AnsiSkippingString::sentinel ) {
+ break;
+ }
+ // if we've read an ansi sequence, set the iterator and
+ // return to the top of the loop
+ m_it = cursor + 1;
+ }
+ }
+
+ void AnsiSkippingString::const_iterator::advance() {
+ assert( m_it != m_string->end() );
+ m_it++;
+ tryParseAnsiEscapes();
+ }
+
+ void AnsiSkippingString::const_iterator::unadvance() {
+ assert( m_it != m_string->begin() );
+ m_it--;
+ // if *m_it is 0xff, scan back to the \033 and then m_it-- once more
+ // (and repeat check)
+ while ( *m_it == AnsiSkippingString::sentinel ) {
+ while ( *m_it != '\033' ) {
+ assert( m_it != m_string->begin() );
+ m_it--;
+ }
+ // if this happens, we must have been a begin iterator that had
+ // skipped over ansi sequences at the start of a string
+ assert( m_it != m_string->begin() );
+ assert( *m_it == '\033' );
+ m_it--;
+ }
+ }
+
+ static bool isBoundary( AnsiSkippingString const& line,
+ AnsiSkippingString::const_iterator it ) {
+ return it == line.end() ||
+ ( isWhitespace( *it ) &&
+ !isWhitespace( *it.oneBefore() ) ) ||
+ isBreakableBefore( *it ) ||
+ isBreakableAfter( *it.oneBefore() );
+ }
+
+ void Column::const_iterator::calcLength() {
+ m_addHyphen = false;
+ m_parsedTo = m_lineStart;
+ AnsiSkippingString const& current_line = m_column.m_string;
+
+ if ( m_parsedTo == current_line.end() ) {
+ m_lineEnd = m_parsedTo;
+ return;
+ }
+
+ assert( m_lineStart != current_line.end() );
+ if ( *m_lineStart == '\n' ) { ++m_parsedTo; }
+
+ const auto maxLineLength = m_column.m_width - indentSize();
+ std::size_t lineLength = 0;
+ while ( m_parsedTo != current_line.end() &&
+ lineLength < maxLineLength && *m_parsedTo != '\n' ) {
+ ++m_parsedTo;
+ ++lineLength;
+ }
+
+ // If we encountered a newline before the column is filled,
+ // then we linebreak at the newline and consider this line
+ // finished.
+ if ( lineLength < maxLineLength ) {
+ m_lineEnd = m_parsedTo;
+ } else {
+ // Look for a natural linebreak boundary in the column
+ // (We look from the end, so that the first found boundary is
+ // the right one)
+ m_lineEnd = m_parsedTo;
+ while ( lineLength > 0 &&
+ !isBoundary( current_line, m_lineEnd ) ) {
+ --lineLength;
+ --m_lineEnd;
+ }
+ while ( lineLength > 0 &&
+ isWhitespace( *m_lineEnd.oneBefore() ) ) {
+ --lineLength;
+ --m_lineEnd;
+ }
+
+ // If we found one, then that is where we linebreak, otherwise
+ // we have to split text with a hyphen
+ if ( lineLength == 0 ) {
+ m_addHyphen = true;
+ m_lineEnd = m_parsedTo.oneBefore();
+ }
+ }
+ }
+
+ size_t Column::const_iterator::indentSize() const {
+ auto initial = m_lineStart == m_column.m_string.begin()
+ ? m_column.m_initialIndent
+ : std::string::npos;
+ return initial == std::string::npos ? m_column.m_indent : initial;
+ }
+
+ std::string Column::const_iterator::addIndentAndSuffix(
+ AnsiSkippingString::const_iterator start,
+ AnsiSkippingString::const_iterator end ) const {
+ std::string ret;
+ const auto desired_indent = indentSize();
+ // ret.reserve( desired_indent + (end - start) + m_addHyphen );
+ ret.append( desired_indent, ' ' );
+ // ret.append( start, end );
+ ret += m_column.m_string.substring( start, end );
+ if ( m_addHyphen ) { ret.push_back( '-' ); }
+
+ return ret;
+ }
+
+ Column::const_iterator::const_iterator( Column const& column ):
+ m_column( column ),
+ m_lineStart( column.m_string.begin() ),
+ m_lineEnd( column.m_string.begin() ),
+ m_parsedTo( column.m_string.begin() ) {
+ assert( m_column.m_width > m_column.m_indent );
+ assert( m_column.m_initialIndent == std::string::npos ||
+ m_column.m_width > m_column.m_initialIndent );
+ calcLength();
+ if ( m_lineStart == m_lineEnd ) {
+ m_lineStart = m_column.m_string.end();
+ }
+ }
+
+ std::string Column::const_iterator::operator*() const {
+ assert( m_lineStart <= m_parsedTo );
+ return addIndentAndSuffix( m_lineStart, m_lineEnd );
+ }
+
+ Column::const_iterator& Column::const_iterator::operator++() {
+ m_lineStart = m_lineEnd;
+ AnsiSkippingString const& current_line = m_column.m_string;
+ if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) {
+ m_lineStart++;
+ } else {
+ while ( m_lineStart != current_line.end() &&
+ isWhitespace( *m_lineStart ) ) {
+ ++m_lineStart;
+ }
+ }
+
+ if ( m_lineStart != current_line.end() ) { calcLength(); }
+ return *this;
+ }
+
+ Column::const_iterator Column::const_iterator::operator++( int ) {
+ const_iterator prev( *this );
+ operator++();
+ return prev;
+ }
+
+ std::ostream& operator<<( std::ostream& os, Column const& col ) {
+ bool first = true;
+ for ( auto line : col ) {
+ if ( first ) {
+ first = false;
+ } else {
+ os << '\n';
+ }
+ os << line;
+ }
+ return os;
+ }
+
+ Column Spacer( size_t spaceWidth ) {
+ Column ret{ "" };
+ ret.width( spaceWidth );
+ return ret;
+ }
+
+ Columns::iterator::iterator( Columns const& columns, EndTag ):
+ m_columns( columns.m_columns ), m_activeIterators( 0 ) {
+
+ m_iterators.reserve( m_columns.size() );
+ for ( auto const& col : m_columns ) {
+ m_iterators.push_back( col.end() );
+ }
+ }
+
+ Columns::iterator::iterator( Columns const& columns ):
+ m_columns( columns.m_columns ),
+ m_activeIterators( m_columns.size() ) {
+
+ m_iterators.reserve( m_columns.size() );
+ for ( auto const& col : m_columns ) {
+ m_iterators.push_back( col.begin() );
+ }
+ }
+
+ std::string Columns::iterator::operator*() const {
+ std::string row, padding;
+
+ for ( size_t i = 0; i < m_columns.size(); ++i ) {
+ const auto width = m_columns[i].width();
+ if ( m_iterators[i] != m_columns[i].end() ) {
+ std::string col = *m_iterators[i];
+ row += padding;
+ row += col;
+
+ padding.clear();
+ if ( col.size() < width ) {
+ padding.append( width - col.size(), ' ' );
+ }
+ } else {
+ padding.append( width, ' ' );
+ }
+ }
+ return row;
+ }
+
+ Columns::iterator& Columns::iterator::operator++() {
+ for ( size_t i = 0; i < m_columns.size(); ++i ) {
+ if ( m_iterators[i] != m_columns[i].end() ) {
+ ++m_iterators[i];
+ }
+ }
+ return *this;
+ }
+
+ Columns::iterator Columns::iterator::operator++( int ) {
+ iterator prev( *this );
+ operator++();
+ return prev;
+ }
+
+ std::ostream& operator<<( std::ostream& os, Columns const& cols ) {
+ bool first = true;
+ for ( auto line : cols ) {
+ if ( first ) {
+ first = false;
+ } else {
+ os << '\n';
+ }
+ os << line;
+ }
+ return os;
+ }
+
+ Columns operator+( Column const& lhs, Column const& rhs ) {
+ Columns cols;
+ cols += lhs;
+ cols += rhs;
+ return cols;
+ }
+ Columns operator+( Column&& lhs, Column&& rhs ) {
+ Columns cols;
+ cols += CATCH_MOVE( lhs );
+ cols += CATCH_MOVE( rhs );
+ return cols;
+ }
+
+ Columns& operator+=( Columns& lhs, Column const& rhs ) {
+ lhs.m_columns.push_back( rhs );
+ return lhs;
+ }
+ Columns& operator+=( Columns& lhs, Column&& rhs ) {
+ lhs.m_columns.push_back( CATCH_MOVE( rhs ) );
+ return lhs;
+ }
+ Columns operator+( Columns const& lhs, Column const& rhs ) {
+ auto combined( lhs );
+ combined += rhs;
+ return combined;
+ }
+ Columns operator+( Columns&& lhs, Column&& rhs ) {
+ lhs += CATCH_MOVE( rhs );
+ return CATCH_MOVE( lhs );
+ }
+
+ } // namespace TextFlow
+} // namespace Catch
+
+
+
+
+#include <exception>
+
+namespace Catch {
+ bool uncaught_exceptions() {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+ return false;
+#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+ return std::uncaught_exceptions() > 0;
+#else
+ return std::uncaught_exception();
+#endif
+ }
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+ WildcardPattern::WildcardPattern( std::string const& pattern,
+ CaseSensitive caseSensitivity )
+ : m_caseSensitivity( caseSensitivity ),
+ m_pattern( normaliseString( pattern ) )
+ {
+ if( startsWith( m_pattern, '*' ) ) {
+ m_pattern = m_pattern.substr( 1 );
+ m_wildcard = WildcardAtStart;
+ }
+ if( endsWith( m_pattern, '*' ) ) {
+ m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
+ m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+ }
+ }
+
+ bool WildcardPattern::matches( std::string const& str ) const {
+ switch( m_wildcard ) {
+ case NoWildcard:
+ return m_pattern == normaliseString( str );
+ case WildcardAtStart:
+ return endsWith( normaliseString( str ), m_pattern );
+ case WildcardAtEnd:
+ return startsWith( normaliseString( str ), m_pattern );
+ case WildcardAtBothEnds:
+ return contains( normaliseString( str ), m_pattern );
+ default:
+ CATCH_INTERNAL_ERROR( "Unknown enum" );
+ }
+ }
+
+ std::string WildcardPattern::normaliseString( std::string const& str ) const {
+ return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
+ }
+}
+
+
+// Note: swapping these two includes around causes MSVC to error out
+// while in /permissive- mode. No, I don't know why.
+// Tested on VS 2019, 18.{3, 4}.x
+
+#include <cstdint>
+#include <iomanip>
+#include <type_traits>
+
+namespace Catch {
+
+namespace {
+
+ size_t trailingBytes(unsigned char c) {
+ if ((c & 0xE0) == 0xC0) {
+ return 2;
+ }
+ if ((c & 0xF0) == 0xE0) {
+ return 3;
+ }
+ if ((c & 0xF8) == 0xF0) {
+ return 4;
+ }
+ CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+ }
+
+ uint32_t headerValue(unsigned char c) {
+ if ((c & 0xE0) == 0xC0) {
+ return c & 0x1F;
+ }
+ if ((c & 0xF0) == 0xE0) {
+ return c & 0x0F;
+ }
+ if ((c & 0xF8) == 0xF0) {
+ return c & 0x07;
+ }
+ CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+ }
+
+ void hexEscapeChar(std::ostream& os, unsigned char c) {
+ std::ios_base::fmtflags f(os.flags());
+ os << "\\x"
+ << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+ << static_cast<int>(c);
+ os.flags(f);
+ }
+
+ bool shouldNewline(XmlFormatting fmt) {
+ return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline));
+ }
+
+ bool shouldIndent(XmlFormatting fmt) {
+ return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent));
+ }
+
+} // anonymous namespace
+
+ XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
+ return static_cast<XmlFormatting>(
+ static_cast<std::underlying_type_t<XmlFormatting>>(lhs) |
+ static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
+ );
+ }
+
+ XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
+ return static_cast<XmlFormatting>(
+ static_cast<std::underlying_type_t<XmlFormatting>>(lhs) &
+ static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
+ );
+ }
+
+
+ XmlEncode::XmlEncode( StringRef str, ForWhat forWhat )
+ : m_str( str ),
+ m_forWhat( forWhat )
+ {}
+
+ void XmlEncode::encodeTo( std::ostream& os ) const {
+ // Apostrophe escaping not necessary if we always use " to write attributes
+ // (see: http://www.w3.org/TR/xml/#syntax)
+
+ for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
+ unsigned char c = static_cast<unsigned char>(m_str[idx]);
+ switch (c) {
+ case '<': os << "<"; break;
+ case '&': os << "&"; break;
+
+ case '>':
+ // See: http://www.w3.org/TR/xml/#syntax
+ if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
+ os << ">";
+ else
+ os << c;
+ break;
+
+ case '\"':
+ if (m_forWhat == ForAttributes)
+ os << """;
+ else
+ os << c;
+ break;
+
+ default:
+ // Check for control characters and invalid utf-8
+
+ // Escape control characters in standard ascii
+ // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+ if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
+ hexEscapeChar(os, c);
+ break;
+ }
+
+ // Plain ASCII: Write it to stream
+ if (c < 0x7F) {
+ os << c;
+ break;
+ }
+
+ // UTF-8 territory
+ // Check if the encoding is valid and if it is not, hex escape bytes.
+ // Important: We do not check the exact decoded values for validity, only the encoding format
+ // First check that this bytes is a valid lead byte:
+ // This means that it is not encoded as 1111 1XXX
+ // Or as 10XX XXXX
+ if (c < 0xC0 ||
+ c >= 0xF8) {
+ hexEscapeChar(os, c);
+ break;
+ }
+
+ auto encBytes = trailingBytes(c);
+ // Are there enough bytes left to avoid accessing out-of-bounds memory?
+ if (idx + encBytes - 1 >= m_str.size()) {
+ hexEscapeChar(os, c);
+ break;
+ }
+ // The header is valid, check data
+ // The next encBytes bytes must together be a valid utf-8
+ // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
+ bool valid = true;
+ uint32_t value = headerValue(c);
+ for (std::size_t n = 1; n < encBytes; ++n) {
+ unsigned char nc = static_cast<unsigned char>(m_str[idx + n]);
+ valid &= ((nc & 0xC0) == 0x80);
+ value = (value << 6) | (nc & 0x3F);
+ }
+
+ if (
+ // Wrong bit pattern of following bytes
+ (!valid) ||
+ // Overlong encodings
+ (value < 0x80) ||
+ (0x80 <= value && value < 0x800 && encBytes > 2) ||
+ (0x800 < value && value < 0x10000 && encBytes > 3) ||
+ // Encoded value out of range
+ (value >= 0x110000)
+ ) {
+ hexEscapeChar(os, c);
+ break;
+ }
+
+ // If we got here, this is in fact a valid(ish) utf-8 sequence
+ for (std::size_t n = 0; n < encBytes; ++n) {
+ os << m_str[idx + n];
+ }
+ idx += encBytes - 1;
+ break;
+ }
+ }
+ }
+
+ std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
+ xmlEncode.encodeTo( os );
+ return os;
+ }
+
+ XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
+ : m_writer( writer ),
+ m_fmt(fmt)
+ {}
+
+ XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
+ : m_writer( other.m_writer ),
+ m_fmt(other.m_fmt)
+ {
+ other.m_writer = nullptr;
+ other.m_fmt = XmlFormatting::None;
+ }
+ XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
+ if ( m_writer ) {
+ m_writer->endElement();
+ }
+ m_writer = other.m_writer;
+ other.m_writer = nullptr;
+ m_fmt = other.m_fmt;
+ other.m_fmt = XmlFormatting::None;
+ return *this;
+ }
+
+
+ XmlWriter::ScopedElement::~ScopedElement() {
+ if (m_writer) {
+ m_writer->endElement(m_fmt);
+ }
+ }
+
+ XmlWriter::ScopedElement&
+ XmlWriter::ScopedElement::writeText( StringRef text, XmlFormatting fmt ) {
+ m_writer->writeText( text, fmt );
+ return *this;
+ }
+
+ XmlWriter::ScopedElement&
+ XmlWriter::ScopedElement::writeAttribute( StringRef name,
+ StringRef attribute ) {
+ m_writer->writeAttribute( name, attribute );
+ return *this;
+ }
+
+
+ XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
+ {
+ writeDeclaration();
+ }
+
+ XmlWriter::~XmlWriter() {
+ while (!m_tags.empty()) {
+ endElement();
+ }
+ newlineIfNecessary();
+ }
+
+ XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
+ ensureTagClosed();
+ newlineIfNecessary();
+ if (shouldIndent(fmt)) {
+ m_os << m_indent;
+ m_indent += " ";
+ }
+ m_os << '<' << name;
+ m_tags.push_back( name );
+ m_tagIsOpen = true;
+ applyFormatting(fmt);
+ return *this;
+ }
+
+ XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
+ ScopedElement scoped( this, fmt );
+ startElement( name, fmt );
+ return scoped;
+ }
+
+ XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
+ m_indent = m_indent.substr(0, m_indent.size() - 2);
+
+ if( m_tagIsOpen ) {
+ m_os << "/>";
+ m_tagIsOpen = false;
+ } else {
+ newlineIfNecessary();
+ if (shouldIndent(fmt)) {
+ m_os << m_indent;
+ }
+ m_os << "</" << m_tags.back() << '>';
+ }
+ m_os << std::flush;
+ applyFormatting(fmt);
+ m_tags.pop_back();
+ return *this;
+ }
+
+ XmlWriter& XmlWriter::writeAttribute( StringRef name,
+ StringRef attribute ) {
+ if( !name.empty() && !attribute.empty() )
+ m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+ return *this;
+ }
+
+ XmlWriter& XmlWriter::writeAttribute( StringRef name, bool attribute ) {
+ writeAttribute(name, (attribute ? "true"_sr : "false"_sr));
+ return *this;
+ }
+
+ XmlWriter& XmlWriter::writeAttribute( StringRef name,
+ char const* attribute ) {
+ writeAttribute( name, StringRef( attribute ) );
+ return *this;
+ }
+
+ XmlWriter& XmlWriter::writeText( StringRef text, XmlFormatting fmt ) {
+ CATCH_ENFORCE(!m_tags.empty(), "Cannot write text as top level element");
+ if( !text.empty() ){
+ bool tagWasOpen = m_tagIsOpen;
+ ensureTagClosed();
+ if (tagWasOpen && shouldIndent(fmt)) {
+ m_os << m_indent;
+ }
+ m_os << XmlEncode( text, XmlEncode::ForTextNodes );
+ applyFormatting(fmt);
+ }
+ return *this;
+ }
+
+ XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) {
+ ensureTagClosed();
+ if (shouldIndent(fmt)) {
+ m_os << m_indent;
+ }
+ m_os << "<!-- " << text << " -->";
+ applyFormatting(fmt);
+ return *this;
+ }
+
+ void XmlWriter::writeStylesheetRef( StringRef url ) {
+ m_os << R"(<?xml-stylesheet type="text/xsl" href=")" << url << R"("?>)" << '\n';
+ }
+
+ void XmlWriter::ensureTagClosed() {
+ if( m_tagIsOpen ) {
+ m_os << '>' << std::flush;
+ newlineIfNecessary();
+ m_tagIsOpen = false;
+ }
+ }
+
+ void XmlWriter::applyFormatting(XmlFormatting fmt) {
+ m_needsNewline = shouldNewline(fmt);
+ }
+
+ void XmlWriter::writeDeclaration() {
+ m_os << R"(<?xml version="1.0" encoding="UTF-8"?>)" << '\n';
+ }
+
+ void XmlWriter::newlineIfNecessary() {
+ if( m_needsNewline ) {
+ m_os << '\n' << std::flush;
+ m_needsNewline = false;
+ }
+ }
+}
+
+
+
+
+
+namespace Catch {
+namespace Matchers {
+
+ std::string MatcherUntypedBase::toString() const {
+ if (m_cachedToString.empty()) {
+ m_cachedToString = describe();
+ }
+ return m_cachedToString;
+ }
+
+ MatcherUntypedBase::~MatcherUntypedBase() = default;
+
+} // namespace Matchers
+} // namespace Catch
+
+
+
+
+namespace Catch {
+namespace Matchers {
+
+ std::string IsEmptyMatcher::describe() const {
+ return "is empty";
+ }
+
+ std::string HasSizeMatcher::describe() const {
+ ReusableStringStream sstr;
+ sstr << "has size == " << m_target_size;
+ return sstr.str();
+ }
+
+ IsEmptyMatcher IsEmpty() {
+ return {};
+ }
+
+ HasSizeMatcher SizeIs(std::size_t sz) {
+ return HasSizeMatcher{ sz };
+ }
+
+} // end namespace Matchers
+} // end namespace Catch
+
+
+
+namespace Catch {
+namespace Matchers {
+
+bool ExceptionMessageMatcher::match(std::exception const& ex) const {
+ return ex.what() == m_message;
+}
+
+std::string ExceptionMessageMatcher::describe() const {
+ return "exception message matches \"" + m_message + '"';
+}
+
+ExceptionMessageMatcher Message(std::string const& message) {
+ return ExceptionMessageMatcher(message);
+}
+
+} // namespace Matchers
+} // namespace Catch
+
+
+
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstdint>
+#include <sstream>
+#include <iomanip>
+#include <limits>
+
+
+namespace Catch {
+namespace {
+
+ template <typename FP>
+ bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
+ // Comparison with NaN should always be false.
+ // This way we can rule it out before getting into the ugly details
+ if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+ return false;
+ }
+
+ // This should also handle positive and negative zeros, infinities
+ const auto ulpDist = ulpDistance(lhs, rhs);
+
+ return ulpDist <= maxUlpDiff;
+ }
+
+
+template <typename FP>
+FP step(FP start, FP direction, uint64_t steps) {
+ for (uint64_t i = 0; i < steps; ++i) {
+ start = Catch::nextafter(start, direction);
+ }
+ return start;
+}
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+ return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+template <typename FloatingPoint>
+void write(std::ostream& out, FloatingPoint num) {
+ out << std::scientific
+ << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
+ << num;
+}
+
+} // end anonymous namespace
+
+namespace Matchers {
+namespace Detail {
+
+ enum class FloatingPointKind : uint8_t {
+ Float,
+ Double
+ };
+
+} // end namespace Detail
+
+
+ WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
+ :m_target{ target }, m_margin{ margin } {
+ CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
+ << " Margin has to be non-negative.");
+ }
+
+ // Performs equivalent check of std::fabs(lhs - rhs) <= margin
+ // But without the subtraction to allow for INFINITY in comparison
+ bool WithinAbsMatcher::match(double const& matchee) const {
+ return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
+ }
+
+ std::string WithinAbsMatcher::describe() const {
+ return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
+ }
+
+
+ WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, Detail::FloatingPointKind baseType)
+ :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
+ CATCH_ENFORCE(m_type == Detail::FloatingPointKind::Double
+ || m_ulps < (std::numeric_limits<uint32_t>::max)(),
+ "Provided ULP is impossibly large for a float comparison.");
+ CATCH_ENFORCE( std::numeric_limits<double>::is_iec559,
+ "WithinUlp matcher only supports platforms with "
+ "IEEE-754 compatible floating point representation" );
+ }
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Clang <3.5 reports on the default branch in the switch below
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+
+ bool WithinUlpsMatcher::match(double const& matchee) const {
+ switch (m_type) {
+ case Detail::FloatingPointKind::Float:
+ return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
+ case Detail::FloatingPointKind::Double:
+ return almostEqualUlps<double>(matchee, m_target, m_ulps);
+ default:
+ CATCH_INTERNAL_ERROR( "Unknown Detail::FloatingPointKind value" );
+ }
+ }
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+ std::string WithinUlpsMatcher::describe() const {
+ std::stringstream ret;
+
+ ret << "is within " << m_ulps << " ULPs of ";
+
+ if (m_type == Detail::FloatingPointKind::Float) {
+ write(ret, static_cast<float>(m_target));
+ ret << 'f';
+ } else {
+ write(ret, m_target);
+ }
+
+ ret << " ([";
+ if (m_type == Detail::FloatingPointKind::Double) {
+ write( ret,
+ step( m_target,
+ -std::numeric_limits<double>::infinity(),
+ m_ulps ) );
+ ret << ", ";
+ write( ret,
+ step( m_target,
+ std::numeric_limits<double>::infinity(),
+ m_ulps ) );
+ } else {
+ // We have to cast INFINITY to float because of MinGW, see #1782
+ write( ret,
+ step( static_cast<float>( m_target ),
+ -std::numeric_limits<float>::infinity(),
+ m_ulps ) );
+ ret << ", ";
+ write( ret,
+ step( static_cast<float>( m_target ),
+ std::numeric_limits<float>::infinity(),
+ m_ulps ) );
+ }
+ ret << "])";
+
+ return ret.str();
+ }
+
+ WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
+ m_target(target),
+ m_epsilon(epsilon){
+ CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon < 0 does not make sense.");
+ CATCH_ENFORCE(m_epsilon < 1., "Relative comparison with epsilon >= 1 does not make sense.");
+ }
+
+ bool WithinRelMatcher::match(double const& matchee) const {
+ const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
+ return marginComparison(matchee, m_target,
+ std::isinf(relMargin)? 0 : relMargin);
+ }
+
+ std::string WithinRelMatcher::describe() const {
+ Catch::ReusableStringStream sstr;
+ sstr << "and " << ::Catch::Detail::stringify(m_target) << " are within " << m_epsilon * 100. << "% of each other";
+ return sstr.str();
+ }
+
+
+WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
+ return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Double);
+}
+
+WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
+ return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Float);
+}
+
+WithinAbsMatcher WithinAbs(double target, double margin) {
+ return WithinAbsMatcher(target, margin);
+}
+
+WithinRelMatcher WithinRel(double target, double eps) {
+ return WithinRelMatcher(target, eps);
+}
+
+WithinRelMatcher WithinRel(double target) {
+ return WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
+}
+
+WithinRelMatcher WithinRel(float target, float eps) {
+ return WithinRelMatcher(target, eps);
+}
+
+WithinRelMatcher WithinRel(float target) {
+ return WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
+}
+
+
+
+bool IsNaNMatcher::match( double const& matchee ) const {
+ return std::isnan( matchee );
+}
+
+std::string IsNaNMatcher::describe() const {
+ using namespace std::string_literals;
+ return "is NaN"s;
+}
+
+IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
+
+ } // namespace Matchers
+} // namespace Catch
+
+
+
+
+std::string Catch::Matchers::Detail::finalizeDescription(const std::string& desc) {
+ if (desc.empty()) {
+ return "matches undescribed predicate";
+ } else {
+ return "matches predicate: \"" + desc + '"';
+ }
+}
+
+
+
+namespace Catch {
+ namespace Matchers {
+ std::string AllTrueMatcher::describe() const { return "contains only true"; }
+
+ AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
+
+ std::string NoneTrueMatcher::describe() const { return "contains no true"; }
+
+ NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
+
+ std::string AnyTrueMatcher::describe() const { return "contains at least one true"; }
+
+ AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
+ } // namespace Matchers
+} // namespace Catch
+
+
+
+#include <regex>
+
+namespace Catch {
+namespace Matchers {
+
+ CasedString::CasedString( std::string const& str, CaseSensitive caseSensitivity )
+ : m_caseSensitivity( caseSensitivity ),
+ m_str( adjustString( str ) )
+ {}
+ std::string CasedString::adjustString( std::string const& str ) const {
+ return m_caseSensitivity == CaseSensitive::No
+ ? toLower( str )
+ : str;
+ }
+ StringRef CasedString::caseSensitivitySuffix() const {
+ return m_caseSensitivity == CaseSensitive::Yes
+ ? StringRef()
+ : " (case insensitive)"_sr;
+ }
+
+
+ StringMatcherBase::StringMatcherBase( StringRef operation, CasedString const& comparator )
+ : m_comparator( comparator ),
+ m_operation( operation ) {
+ }
+
+ std::string StringMatcherBase::describe() const {
+ std::string description;
+ description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+ m_comparator.caseSensitivitySuffix().size());
+ description += m_operation;
+ description += ": \"";
+ description += m_comparator.m_str;
+ description += '"';
+ description += m_comparator.caseSensitivitySuffix();
+ return description;
+ }
+
+ StringEqualsMatcher::StringEqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals"_sr, comparator ) {}
+
+ bool StringEqualsMatcher::match( std::string const& source ) const {
+ return m_comparator.adjustString( source ) == m_comparator.m_str;
+ }
+
+
+ StringContainsMatcher::StringContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains"_sr, comparator ) {}
+
+ bool StringContainsMatcher::match( std::string const& source ) const {
+ return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+ }
+
+
+ StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with"_sr, comparator ) {}
+
+ bool StartsWithMatcher::match( std::string const& source ) const {
+ return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+ }
+
+
+ EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with"_sr, comparator ) {}
+
+ bool EndsWithMatcher::match( std::string const& source ) const {
+ return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+ }
+
+
+
+ RegexMatcher::RegexMatcher(std::string regex, CaseSensitive caseSensitivity): m_regex(CATCH_MOVE(regex)), m_caseSensitivity(caseSensitivity) {}
+
+ bool RegexMatcher::match(std::string const& matchee) const {
+ auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
+ if (m_caseSensitivity == CaseSensitive::No) {
+ flags |= std::regex::icase;
+ }
+ auto reg = std::regex(m_regex, flags);
+ return std::regex_match(matchee, reg);
+ }
+
+ std::string RegexMatcher::describe() const {
+ return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Yes)? " case sensitively" : " case insensitively");
+ }
+
+
+ StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity ) {
+ return StringEqualsMatcher( CasedString( str, caseSensitivity) );
+ }
+ StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity ) {
+ return StringContainsMatcher( CasedString( str, caseSensitivity) );
+ }
+ EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity ) {
+ return EndsWithMatcher( CasedString( str, caseSensitivity) );
+ }
+ StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity ) {
+ return StartsWithMatcher( CasedString( str, caseSensitivity) );
+ }
+
+ RegexMatcher Matches(std::string const& regex, CaseSensitive caseSensitivity) {
+ return RegexMatcher(regex, caseSensitivity);
+ }
+
+} // namespace Matchers
+} // namespace Catch
+
+
+
+namespace Catch {
+namespace Matchers {
+ MatcherGenericBase::~MatcherGenericBase() = default;
+
+ namespace Detail {
+
+ std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end) {
+ std::string description;
+ std::size_t combined_size = 4;
+ for ( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
+ combined_size += desc->size();
+ }
+ combined_size += static_cast<size_t>(descriptions_end - descriptions_begin - 1) * combine.size();
+
+ description.reserve(combined_size);
+
+ description += "( ";
+ bool first = true;
+ for( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
+ if( first )
+ first = false;
+ else
+ description += combine;
+ description += *desc;
+ }
+ description += " )";
+ return description;
+ }
+
+ } // namespace Detail
+} // namespace Matchers
+} // namespace Catch
+
+
+
+
+namespace Catch {
+
+ // This is the general overload that takes a any string matcher
+ // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
+ // the Equals matcher (so the header does not mention matchers)
+ void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher ) {
+ std::string exceptionMessage = Catch::translateActiveException();
+ MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher );
+ handler.handleExpr( expr );
+ }
+
+} // namespace Catch
+
+
+
+#include <ostream>
+
+namespace Catch {
+
+ AutomakeReporter::~AutomakeReporter() = default;
+
+ void AutomakeReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+ // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
+ m_stream << ":test-result: ";
+ if ( _testCaseStats.totals.testCases.skipped > 0 ) {
+ m_stream << "SKIP";
+ } else if (_testCaseStats.totals.assertions.allPassed()) {
+ m_stream << "PASS";
+ } else if (_testCaseStats.totals.assertions.allOk()) {
+ m_stream << "XFAIL";
+ } else {
+ m_stream << "FAIL";
+ }
+ m_stream << ' ' << _testCaseStats.testInfo->name << '\n';
+ StreamingReporterBase::testCaseEnded(_testCaseStats);
+ }
+
+ void AutomakeReporter::skipTest(TestCaseInfo const& testInfo) {
+ m_stream << ":test-result: SKIP " << testInfo.name << '\n';
+ }
+
+} // end namespace Catch
+
+
+
+
+
+
+namespace Catch {
+ ReporterBase::ReporterBase( ReporterConfig&& config ):
+ IEventListener( config.fullConfig() ),
+ m_wrapped_stream( CATCH_MOVE(config).takeStream() ),
+ m_stream( m_wrapped_stream->stream() ),
+ m_colour( makeColourImpl( config.colourMode(), m_wrapped_stream.get() ) ),
+ m_customOptions( config.customOptions() )
+ {}
+
+ ReporterBase::~ReporterBase() = default;
+
+ void ReporterBase::listReporters(
+ std::vector<ReporterDescription> const& descriptions ) {
+ defaultListReporters(m_stream, descriptions, m_config->verbosity());
+ }
+
+ void ReporterBase::listListeners(
+ std::vector<ListenerDescription> const& descriptions ) {
+ defaultListListeners( m_stream, descriptions );
+ }
+
+ void ReporterBase::listTests(std::vector<TestCaseHandle> const& tests) {
+ defaultListTests(m_stream,
+ m_colour.get(),
+ tests,
+ m_config->hasTestFilters(),
+ m_config->verbosity());
+ }
+
+ void ReporterBase::listTags(std::vector<TagInfo> const& tags) {
+ defaultListTags( m_stream, tags, m_config->hasTestFilters() );
+ }
+
+} // namespace Catch
+
+
+
+
+#include <ostream>
+
+namespace Catch {
+namespace {
+
+ // Colour::LightGrey
+ static constexpr Colour::Code compactDimColour = Colour::FileName;
+
+#ifdef CATCH_PLATFORM_MAC
+ static constexpr Catch::StringRef compactFailedString = "FAILED"_sr;
+ static constexpr Catch::StringRef compactPassedString = "PASSED"_sr;
+#else
+ static constexpr Catch::StringRef compactFailedString = "failed"_sr;
+ static constexpr Catch::StringRef compactPassedString = "passed"_sr;
+#endif
+
+// Implementation of CompactReporter formatting
+class AssertionPrinter {
+public:
+ AssertionPrinter& operator= (AssertionPrinter const&) = delete;
+ AssertionPrinter(AssertionPrinter const&) = delete;
+ AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages, ColourImpl* colourImpl_)
+ : stream(_stream)
+ , result(_stats.assertionResult)
+ , messages(_stats.infoMessages)
+ , itMessage(_stats.infoMessages.begin())
+ , printInfoMessages(_printInfoMessages)
+ , colourImpl(colourImpl_)
+ {}
+
+ void print() {
+ printSourceInfo();
+
+ itMessage = messages.begin();
+
+ switch (result.getResultType()) {
+ case ResultWas::Ok:
+ printResultType(Colour::ResultSuccess, compactPassedString);
+ printOriginalExpression();
+ printReconstructedExpression();
+ if (!result.hasExpression())
+ printRemainingMessages(Colour::None);
+ else
+ printRemainingMessages();
+ break;
+ case ResultWas::ExpressionFailed:
+ if (result.isOk())
+ printResultType(Colour::ResultSuccess, compactFailedString + " - but was ok"_sr);
+ else
+ printResultType(Colour::Error, compactFailedString);
+ printOriginalExpression();
+ printReconstructedExpression();
+ printRemainingMessages();
+ break;
+ case ResultWas::ThrewException:
+ printResultType(Colour::Error, compactFailedString);
+ printIssue("unexpected exception with message:");
+ printMessage();
+ printExpressionWas();
+ printRemainingMessages();
+ break;
+ case ResultWas::FatalErrorCondition:
+ printResultType(Colour::Error, compactFailedString);
+ printIssue("fatal error condition with message:");
+ printMessage();
+ printExpressionWas();
+ printRemainingMessages();
+ break;
+ case ResultWas::DidntThrowException:
+ printResultType(Colour::Error, compactFailedString);
+ printIssue("expected exception, got none");
+ printExpressionWas();
+ printRemainingMessages();
+ break;
+ case ResultWas::Info:
+ printResultType(Colour::None, "info"_sr);
+ printMessage();
+ printRemainingMessages();
+ break;
+ case ResultWas::Warning:
+ printResultType(Colour::None, "warning"_sr);
+ printMessage();
+ printRemainingMessages();
+ break;
+ case ResultWas::ExplicitFailure:
+ printResultType(Colour::Error, compactFailedString);
+ printIssue("explicitly");
+ printRemainingMessages(Colour::None);
+ break;
+ case ResultWas::ExplicitSkip:
+ printResultType(Colour::Skip, "skipped"_sr);
+ printMessage();
+ printRemainingMessages();
+ break;
+ // These cases are here to prevent compiler warnings
+ case ResultWas::Unknown:
+ case ResultWas::FailureBit:
+ case ResultWas::Exception:
+ printResultType(Colour::Error, "** internal error **");
+ break;
+ }
+ }
+
+private:
+ void printSourceInfo() const {
+ stream << colourImpl->guardColour( Colour::FileName )
+ << result.getSourceInfo() << ':';
+ }
+
+ void printResultType(Colour::Code colour, StringRef passOrFail) const {
+ if (!passOrFail.empty()) {
+ stream << colourImpl->guardColour(colour) << ' ' << passOrFail;
+ stream << ':';
+ }
+ }
+
+ void printIssue(char const* issue) const {
+ stream << ' ' << issue;
+ }
+
+ void printExpressionWas() {
+ if (result.hasExpression()) {
+ stream << ';';
+ {
+ stream << colourImpl->guardColour(compactDimColour) << " expression was:";
+ }
+ printOriginalExpression();
+ }
+ }
+
+ void printOriginalExpression() const {
+ if (result.hasExpression()) {
+ stream << ' ' << result.getExpression();
+ }
+ }
+
+ void printReconstructedExpression() const {
+ if (result.hasExpandedExpression()) {
+ stream << colourImpl->guardColour(compactDimColour) << " for: ";
+ stream << result.getExpandedExpression();
+ }
+ }
+
+ void printMessage() {
+ if (itMessage != messages.end()) {
+ stream << " '" << itMessage->message << '\'';
+ ++itMessage;
+ }
+ }
+
+ void printRemainingMessages(Colour::Code colour = compactDimColour) {
+ if (itMessage == messages.end())
+ return;
+
+ const auto itEnd = messages.cend();
+ const auto N = static_cast<std::size_t>(itEnd - itMessage);
+
+ stream << colourImpl->guardColour( colour ) << " with "
+ << pluralise( N, "message"_sr ) << ':';
+
+ while (itMessage != itEnd) {
+ // If this assertion is a warning ignore any INFO messages
+ if (printInfoMessages || itMessage->type != ResultWas::Info) {
+ printMessage();
+ if (itMessage != itEnd) {
+ stream << colourImpl->guardColour(compactDimColour) << " and";
+ }
+ continue;
+ }
+ ++itMessage;
+ }
+ }
+
+private:
+ std::ostream& stream;
+ AssertionResult const& result;
+ std::vector<MessageInfo> const& messages;
+ std::vector<MessageInfo>::const_iterator itMessage;
+ bool printInfoMessages;
+ ColourImpl* colourImpl;
+};
+
+} // anon namespace
+
+ std::string CompactReporter::getDescription() {
+ return "Reports test results on a single line, suitable for IDEs";
+ }
+
+ void CompactReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+ m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
+ }
+
+ void CompactReporter::testRunStarting( TestRunInfo const& ) {
+ if ( m_config->testSpec().hasFilters() ) {
+ m_stream << m_colour->guardColour( Colour::BrightYellow )
+ << "Filters: "
+ << m_config->testSpec()
+ << '\n';
+ }
+ m_stream << "RNG seed: " << getSeed() << '\n';
+ }
+
+ void CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
+ AssertionResult const& result = _assertionStats.assertionResult;
+
+ bool printInfoMessages = true;
+
+ // Drop out if result was successful and we're not printing those
+ if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+ if( result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip )
+ return;
+ printInfoMessages = false;
+ }
+
+ AssertionPrinter printer( m_stream, _assertionStats, printInfoMessages, m_colour.get() );
+ printer.print();
+
+ m_stream << '\n' << std::flush;
+ }
+
+ void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
+ double dur = _sectionStats.durationInSeconds;
+ if ( shouldShowDuration( *m_config, dur ) ) {
+ m_stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
+ }
+ }
+
+ void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
+ printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
+ m_stream << "\n\n" << std::flush;
+ StreamingReporterBase::testRunEnded( _testRunStats );
+ }
+
+ CompactReporter::~CompactReporter() = default;
+
+} // end namespace Catch
+
+
+
+
+#include <cstdio>
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+ // Note that 4062 (not all labels are handled and default is missing) is enabled
+#endif
+
+#if defined(__clang__)
+# pragma clang diagnostic push
+// For simplicity, benchmarking-only helpers are always enabled
+# pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+
+
+namespace Catch {
+
+namespace {
+
+// Formatter impl for ConsoleReporter
+class ConsoleAssertionPrinter {
+public:
+ ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
+ ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
+ ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, ColourImpl* colourImpl_, bool _printInfoMessages)
+ : stream(_stream),
+ stats(_stats),
+ result(_stats.assertionResult),
+ colour(Colour::None),
+ messages(_stats.infoMessages),
+ colourImpl(colourImpl_),
+ printInfoMessages(_printInfoMessages) {
+ switch (result.getResultType()) {
+ case ResultWas::Ok:
+ colour = Colour::Success;
+ passOrFail = "PASSED"_sr;
+ //if( result.hasMessage() )
+ if (messages.size() == 1)
+ messageLabel = "with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "with messages"_sr;
+ break;
+ case ResultWas::ExpressionFailed:
+ if (result.isOk()) {
+ colour = Colour::Success;
+ passOrFail = "FAILED - but was ok"_sr;
+ } else {
+ colour = Colour::Error;
+ passOrFail = "FAILED"_sr;
+ }
+ if (messages.size() == 1)
+ messageLabel = "with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "with messages"_sr;
+ break;
+ case ResultWas::ThrewException:
+ colour = Colour::Error;
+ passOrFail = "FAILED"_sr;
+ // todo switch
+ switch (messages.size()) { case 0:
+ messageLabel = "due to unexpected exception with "_sr;
+ break;
+ case 1:
+ messageLabel = "due to unexpected exception with message"_sr;
+ break;
+ default:
+ messageLabel = "due to unexpected exception with messages"_sr;
+ break;
+ }
+ break;
+ case ResultWas::FatalErrorCondition:
+ colour = Colour::Error;
+ passOrFail = "FAILED"_sr;
+ messageLabel = "due to a fatal error condition"_sr;
+ break;
+ case ResultWas::DidntThrowException:
+ colour = Colour::Error;
+ passOrFail = "FAILED"_sr;
+ messageLabel = "because no exception was thrown where one was expected"_sr;
+ break;
+ case ResultWas::Info:
+ messageLabel = "info"_sr;
+ break;
+ case ResultWas::Warning:
+ messageLabel = "warning"_sr;
+ break;
+ case ResultWas::ExplicitFailure:
+ passOrFail = "FAILED"_sr;
+ colour = Colour::Error;
+ if (messages.size() == 1)
+ messageLabel = "explicitly with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "explicitly with messages"_sr;
+ break;
+ case ResultWas::ExplicitSkip:
+ colour = Colour::Skip;
+ passOrFail = "SKIPPED"_sr;
+ if (messages.size() == 1)
+ messageLabel = "explicitly with message"_sr;
+ if (messages.size() > 1)
+ messageLabel = "explicitly with messages"_sr;
+ break;
+ // These cases are here to prevent compiler warnings
+ case ResultWas::Unknown:
+ case ResultWas::FailureBit:
+ case ResultWas::Exception:
+ passOrFail = "** internal error **"_sr;
+ colour = Colour::Error;
+ break;
+ }
+ }
+
+ void print() const {
+ printSourceInfo();
+ if (stats.totals.assertions.total() > 0) {
+ printResultType();
+ printOriginalExpression();
+ printReconstructedExpression();
+ } else {
+ stream << '\n';
+ }
+ printMessage();
+ }
+
+private:
+ void printResultType() const {
+ if (!passOrFail.empty()) {
+ stream << colourImpl->guardColour(colour) << passOrFail << ":\n";
+ }
+ }
+ void printOriginalExpression() const {
+ if (result.hasExpression()) {
+ stream << colourImpl->guardColour( Colour::OriginalExpression )
+ << " " << result.getExpressionInMacro() << '\n';
+ }
+ }
+ void printReconstructedExpression() const {
+ if (result.hasExpandedExpression()) {
+ stream << "with expansion:\n";
+ stream << colourImpl->guardColour( Colour::ReconstructedExpression )
+ << TextFlow::Column( result.getExpandedExpression() )
+ .indent( 2 )
+ << '\n';
+ }
+ }
+ void printMessage() const {
+ if (!messageLabel.empty())
+ stream << messageLabel << ':' << '\n';
+ for (auto const& msg : messages) {
+ // If this assertion is a warning ignore any INFO messages
+ if (printInfoMessages || msg.type != ResultWas::Info)
+ stream << TextFlow::Column(msg.message).indent(2) << '\n';
+ }
+ }
+ void printSourceInfo() const {
+ stream << colourImpl->guardColour( Colour::FileName )
+ << result.getSourceInfo() << ": ";
+ }
+
+ std::ostream& stream;
+ AssertionStats const& stats;
+ AssertionResult const& result;
+ Colour::Code colour;
+ StringRef passOrFail;
+ StringRef messageLabel;
+ std::vector<MessageInfo> const& messages;
+ ColourImpl* colourImpl;
+ bool printInfoMessages;
+};
+
+std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) {
+ const auto ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+ return (ratio == 0 && number > 0) ? 1 : static_cast<std::size_t>(ratio);
+}
+
+std::size_t&
+findMax( std::size_t& i, std::size_t& j, std::size_t& k, std::size_t& l ) {
+ if (i > j && i > k && i > l)
+ return i;
+ else if (j > k && j > l)
+ return j;
+ else if (k > l)
+ return k;
+ else
+ return l;
+}
+
+struct ColumnBreak {};
+struct RowBreak {};
+struct OutputFlush {};
+
+class Duration {
+ enum class Unit {
+ Auto,
+ Nanoseconds,
+ Microseconds,
+ Milliseconds,
+ Seconds,
+ Minutes
+ };
+ static const uint64_t s_nanosecondsInAMicrosecond = 1000;
+ static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
+ static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
+ static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
+
+ double m_inNanoseconds;
+ Unit m_units;
+
+public:
+ explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
+ : m_inNanoseconds(inNanoseconds),
+ m_units(units) {
+ if (m_units == Unit::Auto) {
+ if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
+ m_units = Unit::Nanoseconds;
+ else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
+ m_units = Unit::Microseconds;
+ else if (m_inNanoseconds < s_nanosecondsInASecond)
+ m_units = Unit::Milliseconds;
+ else if (m_inNanoseconds < s_nanosecondsInAMinute)
+ m_units = Unit::Seconds;
+ else
+ m_units = Unit::Minutes;
+ }
+
+ }
+
+ auto value() const -> double {
+ switch (m_units) {
+ case Unit::Microseconds:
+ return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
+ case Unit::Milliseconds:
+ return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
+ case Unit::Seconds:
+ return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
+ case Unit::Minutes:
+ return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
+ default:
+ return m_inNanoseconds;
+ }
+ }
+ StringRef unitsAsString() const {
+ switch (m_units) {
+ case Unit::Nanoseconds:
+ return "ns"_sr;
+ case Unit::Microseconds:
+ return "us"_sr;
+ case Unit::Milliseconds:
+ return "ms"_sr;
+ case Unit::Seconds:
+ return "s"_sr;
+ case Unit::Minutes:
+ return "m"_sr;
+ default:
+ return "** internal error **"_sr;
+ }
+
+ }
+ friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
+ return os << duration.value() << ' ' << duration.unitsAsString();
+ }
+};
+} // end anon namespace
+
+enum class Justification { Left, Right };
+
+struct ColumnInfo {
+ std::string name;
+ std::size_t width;
+ Justification justification;
+};
+
+class TablePrinter {
+ std::ostream& m_os;
+ std::vector<ColumnInfo> m_columnInfos;
+ ReusableStringStream m_oss;
+ int m_currentColumn = -1;
+ bool m_isOpen = false;
+
+public:
+ TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
+ : m_os( os ),
+ m_columnInfos( CATCH_MOVE( columnInfos ) ) {}
+
+ auto columnInfos() const -> std::vector<ColumnInfo> const& {
+ return m_columnInfos;
+ }
+
+ void open() {
+ if (!m_isOpen) {
+ m_isOpen = true;
+ *this << RowBreak();
+
+ TextFlow::Columns headerCols;
+ for (auto const& info : m_columnInfos) {
+ assert(info.width > 2);
+ headerCols += TextFlow::Column(info.name).width(info.width - 2);
+ headerCols += TextFlow::Spacer( 2 );
+ }
+ m_os << headerCols << '\n';
+
+ m_os << lineOfChars('-') << '\n';
+ }
+ }
+ void close() {
+ if (m_isOpen) {
+ *this << RowBreak();
+ m_os << '\n' << std::flush;
+ m_isOpen = false;
+ }
+ }
+
+ template<typename T>
+ friend TablePrinter& operator<< (TablePrinter& tp, T const& value) {
+ tp.m_oss << value;
+ return tp;
+ }
+
+ friend TablePrinter& operator<< (TablePrinter& tp, ColumnBreak) {
+ auto colStr = tp.m_oss.str();
+ const auto strSize = colStr.size();
+ tp.m_oss.str("");
+ tp.open();
+ if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
+ tp.m_currentColumn = -1;
+ tp.m_os << '\n';
+ }
+ tp.m_currentColumn++;
+
+ auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
+ auto padding = (strSize + 1 < colInfo.width)
+ ? std::string(colInfo.width - (strSize + 1), ' ')
+ : std::string();
+ if (colInfo.justification == Justification::Left)
+ tp.m_os << colStr << padding << ' ';
+ else
+ tp.m_os << padding << colStr << ' ';
+ return tp;
+ }
+
+ friend TablePrinter& operator<< (TablePrinter& tp, RowBreak) {
+ if (tp.m_currentColumn > 0) {
+ tp.m_os << '\n';
+ tp.m_currentColumn = -1;
+ }
+ return tp;
+ }
+
+ friend TablePrinter& operator<<(TablePrinter& tp, OutputFlush) {
+ tp.m_os << std::flush;
+ return tp;
+ }
+};
+
+ConsoleReporter::ConsoleReporter(ReporterConfig&& config):
+ StreamingReporterBase( CATCH_MOVE( config ) ),
+ m_tablePrinter(Detail::make_unique<TablePrinter>(m_stream,
+ [&config]() -> std::vector<ColumnInfo> {
+ if (config.fullConfig()->benchmarkNoAnalysis())
+ {
+ return{
+ { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
+ { " samples", 14, Justification::Right },
+ { " iterations", 14, Justification::Right },
+ { " mean", 14, Justification::Right }
+ };
+ }
+ else
+ {
+ return{
+ { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
+ { "samples mean std dev", 14, Justification::Right },
+ { "iterations low mean low std dev", 14, Justification::Right },
+ { "est run time high mean high std dev", 14, Justification::Right }
+ };
+ }
+ }())) {}
+ConsoleReporter::~ConsoleReporter() = default;
+
+std::string ConsoleReporter::getDescription() {
+ return "Reports test results as plain lines of text";
+}
+
+void ConsoleReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+ m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
+}
+
+void ConsoleReporter::reportInvalidTestSpec( StringRef arg ) {
+ m_stream << "Invalid Filter: " << arg << '\n';
+}
+
+void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
+
+void ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
+ AssertionResult const& result = _assertionStats.assertionResult;
+
+ bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+ // Drop out if result was successful but we're not printing them.
+ // TODO: Make configurable whether skips should be printed
+ if (!includeResults && result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip)
+ return;
+
+ lazyPrint();
+
+ ConsoleAssertionPrinter printer(m_stream, _assertionStats, m_colour.get(), includeResults);
+ printer.print();
+ m_stream << '\n' << std::flush;
+}
+
+void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+ m_tablePrinter->close();
+ m_headerPrinted = false;
+ StreamingReporterBase::sectionStarting(_sectionInfo);
+}
+void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
+ m_tablePrinter->close();
+ if (_sectionStats.missingAssertions) {
+ lazyPrint();
+ auto guard =
+ m_colour->guardColour( Colour::ResultError ).engage( m_stream );
+ if (m_sectionStack.size() > 1)
+ m_stream << "\nNo assertions in section";
+ else
+ m_stream << "\nNo assertions in test case";
+ m_stream << " '" << _sectionStats.sectionInfo.name << "'\n\n" << std::flush;
+ }
+ double dur = _sectionStats.durationInSeconds;
+ if (shouldShowDuration(*m_config, dur)) {
+ m_stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
+ }
+ if (m_headerPrinted) {
+ m_headerPrinted = false;
+ }
+ StreamingReporterBase::sectionEnded(_sectionStats);
+}
+
+void ConsoleReporter::benchmarkPreparing( StringRef name ) {
+ lazyPrintWithoutClosingBenchmarkTable();
+
+ auto nameCol = TextFlow::Column( static_cast<std::string>( name ) )
+ .width( m_tablePrinter->columnInfos()[0].width - 2 );
+
+ bool firstLine = true;
+ for (auto line : nameCol) {
+ if (!firstLine)
+ (*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+ else
+ firstLine = false;
+
+ (*m_tablePrinter) << line << ColumnBreak();
+ }
+}
+
+void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+ (*m_tablePrinter) << info.samples << ColumnBreak()
+ << info.iterations << ColumnBreak();
+ if ( !m_config->benchmarkNoAnalysis() ) {
+ ( *m_tablePrinter )
+ << Duration( info.estimatedDuration ) << ColumnBreak();
+ }
+ ( *m_tablePrinter ) << OutputFlush{};
+}
+void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
+ if (m_config->benchmarkNoAnalysis())
+ {
+ (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
+ }
+ else
+ {
+ (*m_tablePrinter) << ColumnBreak()
+ << Duration(stats.mean.point.count()) << ColumnBreak()
+ << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+ << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
+ << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
+ << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
+ << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
+ }
+}
+
+void ConsoleReporter::benchmarkFailed( StringRef error ) {
+ auto guard = m_colour->guardColour( Colour::Red ).engage( m_stream );
+ (*m_tablePrinter)
+ << "Benchmark failed (" << error << ')'
+ << ColumnBreak() << RowBreak();
+}
+
+void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+ m_tablePrinter->close();
+ StreamingReporterBase::testCaseEnded(_testCaseStats);
+ m_headerPrinted = false;
+}
+void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
+ printTotalsDivider(_testRunStats.totals);
+ printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
+ m_stream << '\n' << std::flush;
+ StreamingReporterBase::testRunEnded(_testRunStats);
+}
+void ConsoleReporter::testRunStarting(TestRunInfo const& _testRunInfo) {
+ StreamingReporterBase::testRunStarting(_testRunInfo);
+ if ( m_config->testSpec().hasFilters() ) {
+ m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: "
+ << m_config->testSpec() << '\n';
+ }
+ m_stream << "Randomness seeded to: " << getSeed() << '\n';
+}
+
+void ConsoleReporter::lazyPrint() {
+
+ m_tablePrinter->close();
+ lazyPrintWithoutClosingBenchmarkTable();
+}
+
+void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
+
+ if ( !m_testRunInfoPrinted ) {
+ lazyPrintRunInfo();
+ }
+ if (!m_headerPrinted) {
+ printTestCaseAndSectionHeader();
+ m_headerPrinted = true;
+ }
+}
+void ConsoleReporter::lazyPrintRunInfo() {
+ m_stream << '\n'
+ << lineOfChars( '~' ) << '\n'
+ << m_colour->guardColour( Colour::SecondaryText )
+ << currentTestRunInfo.name << " is a Catch2 v" << libraryVersion()
+ << " host application.\n"
+ << "Run with -? for options\n\n";
+
+ m_testRunInfoPrinted = true;
+}
+void ConsoleReporter::printTestCaseAndSectionHeader() {
+ assert(!m_sectionStack.empty());
+ printOpenHeader(currentTestCaseInfo->name);
+
+ if (m_sectionStack.size() > 1) {
+ auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
+
+ auto
+ it = m_sectionStack.begin() + 1, // Skip first section (test case)
+ itEnd = m_sectionStack.end();
+ for (; it != itEnd; ++it)
+ printHeaderString(it->name, 2);
+ }
+
+ SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
+
+
+ m_stream << lineOfChars( '-' ) << '\n'
+ << m_colour->guardColour( Colour::FileName ) << lineInfo << '\n'
+ << lineOfChars( '.' ) << "\n\n"
+ << std::flush;
+}
+
+void ConsoleReporter::printClosedHeader(std::string const& _name) {
+ printOpenHeader(_name);
+ m_stream << lineOfChars('.') << '\n';
+}
+void ConsoleReporter::printOpenHeader(std::string const& _name) {
+ m_stream << lineOfChars('-') << '\n';
+ {
+ auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
+ printHeaderString(_name);
+ }
+}
+
+void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
+ // We want to get a bit fancy with line breaking here, so that subsequent
+ // lines start after ":" if one is present, e.g.
+ // ```
+ // blablabla: Fancy
+ // linebreaking
+ // ```
+ // but we also want to avoid problems with overly long indentation causing
+ // the text to take up too many lines, e.g.
+ // ```
+ // blablabla: F
+ // a
+ // n
+ // c
+ // y
+ // .
+ // .
+ // .
+ // ```
+ // So we limit the prefix indentation check to first quarter of the possible
+ // width
+ std::size_t idx = _string.find( ": " );
+ if ( idx != std::string::npos && idx < CATCH_CONFIG_CONSOLE_WIDTH / 4 ) {
+ idx += 2;
+ } else {
+ idx = 0;
+ }
+ m_stream << TextFlow::Column( _string )
+ .indent( indent + idx )
+ .initialIndent( indent )
+ << '\n';
+}
+
+void ConsoleReporter::printTotalsDivider(Totals const& totals) {
+ if (totals.testCases.total() > 0) {
+ std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
+ std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
+ std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
+ std::size_t skippedRatio = makeRatio(totals.testCases.skipped, totals.testCases.total());
+ while (failedRatio + failedButOkRatio + passedRatio + skippedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+ findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)++;
+ while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
+ findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)--;
+
+ m_stream << m_colour->guardColour( Colour::Error )
+ << std::string( failedRatio, '=' )
+ << m_colour->guardColour( Colour::ResultExpectedFailure )
+ << std::string( failedButOkRatio, '=' );
+ if ( totals.testCases.allPassed() ) {
+ m_stream << m_colour->guardColour( Colour::ResultSuccess )
+ << std::string( passedRatio, '=' );
+ } else {
+ m_stream << m_colour->guardColour( Colour::Success )
+ << std::string( passedRatio, '=' );
+ }
+ m_stream << m_colour->guardColour( Colour::Skip )
+ << std::string( skippedRatio, '=' );
+ } else {
+ m_stream << m_colour->guardColour( Colour::Warning )
+ << std::string( CATCH_CONFIG_CONSOLE_WIDTH - 1, '=' );
+ }
+ m_stream << '\n';
+}
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+
+
+
+
+#include <algorithm>
+#include <cassert>
+
+namespace Catch {
+ namespace {
+ struct BySectionInfo {
+ BySectionInfo( SectionInfo const& other ): m_other( other ) {}
+ BySectionInfo( BySectionInfo const& other ) = default;
+ bool operator()(
+ Detail::unique_ptr<CumulativeReporterBase::SectionNode> const&
+ node ) const {
+ return (
+ ( node->stats.sectionInfo.name == m_other.name ) &&
+ ( node->stats.sectionInfo.lineInfo == m_other.lineInfo ) );
+ }
+ void operator=( BySectionInfo const& ) = delete;
+
+ private:
+ SectionInfo const& m_other;
+ };
+
+ } // namespace
+
+ namespace Detail {
+ AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
+ AssertionStats const& assertion ):
+ m_assertion( assertion ) {}
+
+ AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
+ BenchmarkStats<> const& benchmark ):
+ m_benchmark( benchmark ) {}
+
+ bool AssertionOrBenchmarkResult::isAssertion() const {
+ return m_assertion.some();
+ }
+ bool AssertionOrBenchmarkResult::isBenchmark() const {
+ return m_benchmark.some();
+ }
+
+ AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
+ assert(m_assertion.some());
+
+ return *m_assertion;
+ }
+ BenchmarkStats<> const& AssertionOrBenchmarkResult::asBenchmark() const {
+ assert(m_benchmark.some());
+
+ return *m_benchmark;
+ }
+
+ }
+
+ CumulativeReporterBase::~CumulativeReporterBase() = default;
+
+ void CumulativeReporterBase::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+ m_sectionStack.back()->assertionsAndBenchmarks.emplace_back(benchmarkStats);
+ }
+
+ void
+ CumulativeReporterBase::sectionStarting( SectionInfo const& sectionInfo ) {
+ // We need a copy, because SectionStats expect to take ownership
+ SectionStats incompleteStats( SectionInfo(sectionInfo), Counts(), 0, false );
+ SectionNode* node;
+ if ( m_sectionStack.empty() ) {
+ if ( !m_rootSection ) {
+ m_rootSection =
+ Detail::make_unique<SectionNode>( incompleteStats );
+ }
+ node = m_rootSection.get();
+ } else {
+ SectionNode& parentNode = *m_sectionStack.back();
+ auto it = std::find_if( parentNode.childSections.begin(),
+ parentNode.childSections.end(),
+ BySectionInfo( sectionInfo ) );
+ if ( it == parentNode.childSections.end() ) {
+ auto newNode =
+ Detail::make_unique<SectionNode>( incompleteStats );
+ node = newNode.get();
+ parentNode.childSections.push_back( CATCH_MOVE( newNode ) );
+ } else {
+ node = it->get();
+ }
+ }
+
+ m_deepestSection = node;
+ m_sectionStack.push_back( node );
+ }
+
+ void CumulativeReporterBase::assertionEnded(
+ AssertionStats const& assertionStats ) {
+ assert( !m_sectionStack.empty() );
+ // AssertionResult holds a pointer to a temporary DecomposedExpression,
+ // which getExpandedExpression() calls to build the expression string.
+ // Our section stack copy of the assertionResult will likely outlive the
+ // temporary, so it must be expanded or discarded now to avoid calling
+ // a destroyed object later.
+ if ( m_shouldStoreFailedAssertions &&
+ !assertionStats.assertionResult.isOk() ) {
+ static_cast<void>(
+ assertionStats.assertionResult.getExpandedExpression() );
+ }
+ if ( m_shouldStoreSuccesfulAssertions &&
+ assertionStats.assertionResult.isOk() ) {
+ static_cast<void>(
+ assertionStats.assertionResult.getExpandedExpression() );
+ }
+ SectionNode& sectionNode = *m_sectionStack.back();
+ sectionNode.assertionsAndBenchmarks.emplace_back( assertionStats );
+ }
+
+ void CumulativeReporterBase::sectionEnded( SectionStats const& sectionStats ) {
+ assert( !m_sectionStack.empty() );
+ SectionNode& node = *m_sectionStack.back();
+ node.stats = sectionStats;
+ m_sectionStack.pop_back();
+ }
+
+ void CumulativeReporterBase::testCaseEnded(
+ TestCaseStats const& testCaseStats ) {
+ auto node = Detail::make_unique<TestCaseNode>( testCaseStats );
+ assert( m_sectionStack.size() == 0 );
+ node->children.push_back( CATCH_MOVE(m_rootSection) );
+ m_testCases.push_back( CATCH_MOVE(node) );
+
+ assert( m_deepestSection );
+ m_deepestSection->stdOut = testCaseStats.stdOut;
+ m_deepestSection->stdErr = testCaseStats.stdErr;
+ }
+
+
+ void CumulativeReporterBase::testRunEnded( TestRunStats const& testRunStats ) {
+ assert(!m_testRun && "CumulativeReporterBase assumes there can only be one test run");
+ m_testRun = Detail::make_unique<TestRunNode>( testRunStats );
+ m_testRun->children.swap( m_testCases );
+ testRunEndedCumulative();
+ }
+
+ bool CumulativeReporterBase::SectionNode::hasAnyAssertions() const {
+ return std::any_of(
+ assertionsAndBenchmarks.begin(),
+ assertionsAndBenchmarks.end(),
+ []( Detail::AssertionOrBenchmarkResult const& res ) {
+ return res.isAssertion();
+ } );
+ }
+
+} // end namespace Catch
+
+
+
+
+namespace Catch {
+
+ void EventListenerBase::fatalErrorEncountered( StringRef ) {}
+
+ void EventListenerBase::benchmarkPreparing( StringRef ) {}
+ void EventListenerBase::benchmarkStarting( BenchmarkInfo const& ) {}
+ void EventListenerBase::benchmarkEnded( BenchmarkStats<> const& ) {}
+ void EventListenerBase::benchmarkFailed( StringRef ) {}
+
+ void EventListenerBase::assertionStarting( AssertionInfo const& ) {}
+
+ void EventListenerBase::assertionEnded( AssertionStats const& ) {}
+ void EventListenerBase::listReporters(
+ std::vector<ReporterDescription> const& ) {}
+ void EventListenerBase::listListeners(
+ std::vector<ListenerDescription> const& ) {}
+ void EventListenerBase::listTests( std::vector<TestCaseHandle> const& ) {}
+ void EventListenerBase::listTags( std::vector<TagInfo> const& ) {}
+ void EventListenerBase::noMatchingTestCases( StringRef ) {}
+ void EventListenerBase::reportInvalidTestSpec( StringRef ) {}
+ void EventListenerBase::testRunStarting( TestRunInfo const& ) {}
+ void EventListenerBase::testCaseStarting( TestCaseInfo const& ) {}
+ void EventListenerBase::testCasePartialStarting(TestCaseInfo const&, uint64_t) {}
+ void EventListenerBase::sectionStarting( SectionInfo const& ) {}
+ void EventListenerBase::sectionEnded( SectionStats const& ) {}
+ void EventListenerBase::testCasePartialEnded(TestCaseStats const&, uint64_t) {}
+ void EventListenerBase::testCaseEnded( TestCaseStats const& ) {}
+ void EventListenerBase::testRunEnded( TestRunStats const& ) {}
+ void EventListenerBase::skipTest( TestCaseInfo const& ) {}
+} // namespace Catch
+
+
+
+
+#include <algorithm>
+#include <cfloat>
+#include <cstdio>
+#include <ostream>
+#include <iomanip>
+
+namespace Catch {
+
+ namespace {
+ void listTestNamesOnly(std::ostream& out,
+ std::vector<TestCaseHandle> const& tests) {
+ for (auto const& test : tests) {
+ auto const& testCaseInfo = test.getTestCaseInfo();
+
+ if (startsWith(testCaseInfo.name, '#')) {
+ out << '"' << testCaseInfo.name << '"';
+ } else {
+ out << testCaseInfo.name;
+ }
+
+ out << '\n';
+ }
+ out << std::flush;
+ }
+ } // end unnamed namespace
+
+
+ // Because formatting using c++ streams is stateful, drop down to C is
+ // required Alternatively we could use stringstream, but its performance
+ // is... not good.
+ std::string getFormattedDuration( double duration ) {
+ // Max exponent + 1 is required to represent the whole part
+ // + 1 for decimal point
+ // + 3 for the 3 decimal places
+ // + 1 for null terminator
+ const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+ char buffer[maxDoubleSize];
+
+ // Save previous errno, to prevent sprintf from overwriting it
+ ErrnoGuard guard;
+#ifdef _MSC_VER
+ size_t printedLength = static_cast<size_t>(
+ sprintf_s( buffer, "%.3f", duration ) );
+#else
+ size_t printedLength = static_cast<size_t>(
+ std::snprintf( buffer, maxDoubleSize, "%.3f", duration ) );
+#endif
+ return std::string( buffer, printedLength );
+ }
+
+ bool shouldShowDuration( IConfig const& config, double duration ) {
+ if ( config.showDurations() == ShowDurations::Always ) {
+ return true;
+ }
+ if ( config.showDurations() == ShowDurations::Never ) {
+ return false;
+ }
+ const double min = config.minDuration();
+ return min >= 0 && duration >= min;
+ }
+
+ std::string serializeFilters( std::vector<std::string> const& filters ) {
+ // We add a ' ' separator between each filter
+ size_t serialized_size = filters.size() - 1;
+ for (auto const& filter : filters) {
+ serialized_size += filter.size();
+ }
+
+ std::string serialized;
+ serialized.reserve(serialized_size);
+ bool first = true;
+
+ for (auto const& filter : filters) {
+ if (!first) {
+ serialized.push_back(' ');
+ }
+ first = false;
+ serialized.append(filter);
+ }
+
+ return serialized;
+ }
+
+ std::ostream& operator<<( std::ostream& out, lineOfChars value ) {
+ for ( size_t idx = 0; idx < CATCH_CONFIG_CONSOLE_WIDTH - 1; ++idx ) {
+ out.put( value.c );
+ }
+ return out;
+ }
+
+ void
+ defaultListReporters( std::ostream& out,
+ std::vector<ReporterDescription> const& descriptions,
+ Verbosity verbosity ) {
+ out << "Available reporters:\n";
+ const auto maxNameLen =
+ std::max_element( descriptions.begin(),
+ descriptions.end(),
+ []( ReporterDescription const& lhs,
+ ReporterDescription const& rhs ) {
+ return lhs.name.size() < rhs.name.size();
+ } )
+ ->name.size();
+
+ for ( auto const& desc : descriptions ) {
+ if ( verbosity == Verbosity::Quiet ) {
+ out << TextFlow::Column( desc.name )
+ .indent( 2 )
+ .width( 5 + maxNameLen )
+ << '\n';
+ } else {
+ out << TextFlow::Column( desc.name + ':' )
+ .indent( 2 )
+ .width( 5 + maxNameLen ) +
+ TextFlow::Column( desc.description )
+ .initialIndent( 0 )
+ .indent( 2 )
+ .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
+ << '\n';
+ }
+ }
+ out << '\n' << std::flush;
+ }
+
+ void defaultListListeners( std::ostream& out,
+ std::vector<ListenerDescription> const& descriptions ) {
+ out << "Registered listeners:\n";
+
+ if(descriptions.empty()) {
+ return;
+ }
+
+ const auto maxNameLen =
+ std::max_element( descriptions.begin(),
+ descriptions.end(),
+ []( ListenerDescription const& lhs,
+ ListenerDescription const& rhs ) {
+ return lhs.name.size() < rhs.name.size();
+ } )
+ ->name.size();
+
+ for ( auto const& desc : descriptions ) {
+ out << TextFlow::Column( static_cast<std::string>( desc.name ) +
+ ':' )
+ .indent( 2 )
+ .width( maxNameLen + 5 ) +
+ TextFlow::Column( desc.description )
+ .initialIndent( 0 )
+ .indent( 2 )
+ .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
+ << '\n';
+ }
+
+ out << '\n' << std::flush;
+ }
+
+ void defaultListTags( std::ostream& out,
+ std::vector<TagInfo> const& tags,
+ bool isFiltered ) {
+ if ( isFiltered ) {
+ out << "Tags for matching test cases:\n";
+ } else {
+ out << "All available tags:\n";
+ }
+
+ for ( auto const& tagCount : tags ) {
+ ReusableStringStream rss;
+ rss << " " << std::setw( 2 ) << tagCount.count << " ";
+ auto str = rss.str();
+ auto wrapper = TextFlow::Column( tagCount.all() )
+ .initialIndent( 0 )
+ .indent( str.size() )
+ .width( CATCH_CONFIG_CONSOLE_WIDTH - 10 );
+ out << str << wrapper << '\n';
+ }
+ out << pluralise(tags.size(), "tag"_sr) << "\n\n" << std::flush;
+ }
+
+ void defaultListTests(std::ostream& out, ColourImpl* streamColour, std::vector<TestCaseHandle> const& tests, bool isFiltered, Verbosity verbosity) {
+ // We special case this to provide the equivalent of old
+ // `--list-test-names-only`, which could then be used by the
+ // `--input-file` option.
+ if (verbosity == Verbosity::Quiet) {
+ listTestNamesOnly(out, tests);
+ return;
+ }
+
+ if (isFiltered) {
+ out << "Matching test cases:\n";
+ } else {
+ out << "All available test cases:\n";
+ }
+
+ for (auto const& test : tests) {
+ auto const& testCaseInfo = test.getTestCaseInfo();
+ Colour::Code colour = testCaseInfo.isHidden()
+ ? Colour::SecondaryText
+ : Colour::None;
+ auto colourGuard = streamColour->guardColour( colour ).engage( out );
+
+ out << TextFlow::Column(testCaseInfo.name).indent(2) << '\n';
+ if (verbosity >= Verbosity::High) {
+ out << TextFlow::Column(Catch::Detail::stringify(testCaseInfo.lineInfo)).indent(4) << '\n';
+ }
+ if (!testCaseInfo.tags.empty() &&
+ verbosity > Verbosity::Quiet) {
+ out << TextFlow::Column(testCaseInfo.tagsAsString()).indent(6) << '\n';
+ }
+ }
+
+ if (isFiltered) {
+ out << pluralise(tests.size(), "matching test case"_sr);
+ } else {
+ out << pluralise(tests.size(), "test case"_sr);
+ }
+ out << "\n\n" << std::flush;
+ }
+
+ namespace {
+ class SummaryColumn {
+ public:
+ SummaryColumn( std::string suffix, Colour::Code colour ):
+ m_suffix( CATCH_MOVE( suffix ) ), m_colour( colour ) {}
+
+ SummaryColumn&& addRow( std::uint64_t count ) && {
+ std::string row = std::to_string(count);
+ auto const new_width = std::max( m_width, row.size() );
+ if ( new_width > m_width ) {
+ for ( auto& oldRow : m_rows ) {
+ oldRow.insert( 0, new_width - m_width, ' ' );
+ }
+ } else {
+ row.insert( 0, m_width - row.size(), ' ' );
+ }
+ m_width = new_width;
+ m_rows.push_back( row );
+ return std::move( *this );
+ }
+
+ std::string const& getSuffix() const { return m_suffix; }
+ Colour::Code getColour() const { return m_colour; }
+ std::string const& getRow( std::size_t index ) const {
+ return m_rows[index];
+ }
+
+ private:
+ std::string m_suffix;
+ Colour::Code m_colour;
+ std::size_t m_width = 0;
+ std::vector<std::string> m_rows;
+ };
+
+ void printSummaryRow( std::ostream& stream,
+ ColourImpl& colour,
+ StringRef label,
+ std::vector<SummaryColumn> const& cols,
+ std::size_t row ) {
+ for ( auto const& col : cols ) {
+ auto const& value = col.getRow( row );
+ auto const& suffix = col.getSuffix();
+ if ( suffix.empty() ) {
+ stream << label << ": ";
+ if ( value != "0" ) {
+ stream << value;
+ } else {
+ stream << colour.guardColour( Colour::Warning )
+ << "- none -";
+ }
+ } else if ( value != "0" ) {
+ stream << colour.guardColour( Colour::LightGrey ) << " | "
+ << colour.guardColour( col.getColour() ) << value
+ << ' ' << suffix;
+ }
+ }
+ stream << '\n';
+ }
+ } // namespace
+
+ void printTestRunTotals( std::ostream& stream,
+ ColourImpl& streamColour,
+ Totals const& totals ) {
+ if ( totals.testCases.total() == 0 ) {
+ stream << streamColour.guardColour( Colour::Warning )
+ << "No tests ran\n";
+ return;
+ }
+
+ if ( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
+ stream << streamColour.guardColour( Colour::ResultSuccess )
+ << "All tests passed";
+ stream << " ("
+ << pluralise( totals.assertions.passed, "assertion"_sr )
+ << " in "
+ << pluralise( totals.testCases.passed, "test case"_sr )
+ << ')' << '\n';
+ return;
+ }
+
+ std::vector<SummaryColumn> columns;
+ // Don't include "skipped assertions" in total count
+ const auto totalAssertionCount =
+ totals.assertions.total() - totals.assertions.skipped;
+ columns.push_back( SummaryColumn( "", Colour::None )
+ .addRow( totals.testCases.total() )
+ .addRow( totalAssertionCount ) );
+ columns.push_back( SummaryColumn( "passed", Colour::Success )
+ .addRow( totals.testCases.passed )
+ .addRow( totals.assertions.passed ) );
+ columns.push_back( SummaryColumn( "failed", Colour::ResultError )
+ .addRow( totals.testCases.failed )
+ .addRow( totals.assertions.failed ) );
+ columns.push_back( SummaryColumn( "skipped", Colour::Skip )
+ .addRow( totals.testCases.skipped )
+ // Don't print "skipped assertions"
+ .addRow( 0 ) );
+ columns.push_back(
+ SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
+ .addRow( totals.testCases.failedButOk )
+ .addRow( totals.assertions.failedButOk ) );
+ printSummaryRow( stream, streamColour, "test cases"_sr, columns, 0 );
+ printSummaryRow( stream, streamColour, "assertions"_sr, columns, 1 );
+ }
+
+} // namespace Catch
+
+
+//
+
+namespace Catch {
+ namespace {
+ void writeSourceInfo( JsonObjectWriter& writer,
+ SourceLineInfo const& sourceInfo ) {
+ auto source_location_writer =
+ writer.write( "source-location"_sr ).writeObject();
+ source_location_writer.write( "filename"_sr )
+ .write( sourceInfo.file );
+ source_location_writer.write( "line"_sr ).write( sourceInfo.line );
+ }
+
+ void writeTags( JsonArrayWriter writer, std::vector<Tag> const& tags ) {
+ for ( auto const& tag : tags ) {
+ writer.write( tag.original );
+ }
+ }
+
+ void writeProperties( JsonArrayWriter writer,
+ TestCaseInfo const& info ) {
+ if ( info.isHidden() ) { writer.write( "is-hidden"_sr ); }
+ if ( info.okToFail() ) { writer.write( "ok-to-fail"_sr ); }
+ if ( info.expectedToFail() ) {
+ writer.write( "expected-to-fail"_sr );
+ }
+ if ( info.throws() ) { writer.write( "throws"_sr ); }
+ }
+
+ } // namespace
+
+ JsonReporter::JsonReporter( ReporterConfig&& config ):
+ StreamingReporterBase{ CATCH_MOVE( config ) } {
+
+ m_preferences.shouldRedirectStdOut = true;
+ // TBD: Do we want to report all assertions? XML reporter does
+ // not, but for machine-parseable reporters I think the answer
+ // should be yes.
+ m_preferences.shouldReportAllAssertions = true;
+
+ m_objectWriters.emplace( m_stream );
+ m_writers.emplace( Writer::Object );
+ auto& writer = m_objectWriters.top();
+
+ writer.write( "version"_sr ).write( 1 );
+
+ {
+ auto metadata_writer = writer.write( "metadata"_sr ).writeObject();
+ metadata_writer.write( "name"_sr ).write( m_config->name() );
+ metadata_writer.write( "rng-seed"_sr ).write( m_config->rngSeed() );
+ metadata_writer.write( "catch2-version"_sr )
+ .write( libraryVersion() );
+ if ( m_config->testSpec().hasFilters() ) {
+ metadata_writer.write( "filters"_sr )
+ .write( m_config->testSpec() );
+ }
+ }
+ }
+
+ JsonReporter::~JsonReporter() {
+ endListing();
+ // TODO: Ensure this closes the top level object, add asserts
+ assert( m_writers.size() == 1 && "Only the top level object should be open" );
+ assert( m_writers.top() == Writer::Object );
+ endObject();
+ m_stream << '\n' << std::flush;
+ assert( m_writers.empty() );
+ }
+
+ JsonArrayWriter& JsonReporter::startArray() {
+ m_arrayWriters.emplace( m_arrayWriters.top().writeArray() );
+ m_writers.emplace( Writer::Array );
+ return m_arrayWriters.top();
+ }
+ JsonArrayWriter& JsonReporter::startArray( StringRef key ) {
+ m_arrayWriters.emplace(
+ m_objectWriters.top().write( key ).writeArray() );
+ m_writers.emplace( Writer::Array );
+ return m_arrayWriters.top();
+ }
+
+ JsonObjectWriter& JsonReporter::startObject() {
+ m_objectWriters.emplace( m_arrayWriters.top().writeObject() );
+ m_writers.emplace( Writer::Object );
+ return m_objectWriters.top();
+ }
+ JsonObjectWriter& JsonReporter::startObject( StringRef key ) {
+ m_objectWriters.emplace(
+ m_objectWriters.top().write( key ).writeObject() );
+ m_writers.emplace( Writer::Object );
+ return m_objectWriters.top();
+ }
+
+ void JsonReporter::endObject() {
+ assert( isInside( Writer::Object ) );
+ m_objectWriters.pop();
+ m_writers.pop();
+ }
+ void JsonReporter::endArray() {
+ assert( isInside( Writer::Array ) );
+ m_arrayWriters.pop();
+ m_writers.pop();
+ }
+
+ bool JsonReporter::isInside( Writer writer ) {
+ return !m_writers.empty() && m_writers.top() == writer;
+ }
+
+ void JsonReporter::startListing() {
+ if ( !m_startedListing ) { startObject( "listings"_sr ); }
+ m_startedListing = true;
+ }
+ void JsonReporter::endListing() {
+ if ( m_startedListing ) { endObject(); }
+ m_startedListing = false;
+ }
+
+ std::string JsonReporter::getDescription() {
+ return "Outputs listings as JSON. Test listing is Work-in-Progress!";
+ }
+
+ void JsonReporter::testRunStarting( TestRunInfo const& runInfo ) {
+ StreamingReporterBase::testRunStarting( runInfo );
+ endListing();
+
+ assert( isInside( Writer::Object ) );
+ startObject( "test-run"_sr );
+ startArray( "test-cases"_sr );
+ }
+
+ static void writeCounts( JsonObjectWriter&& writer, Counts const& counts ) {
+ writer.write( "passed"_sr ).write( counts.passed );
+ writer.write( "failed"_sr ).write( counts.failed );
+ writer.write( "fail-but-ok"_sr ).write( counts.failedButOk );
+ writer.write( "skipped"_sr ).write( counts.skipped );
+ }
+
+ void JsonReporter::testRunEnded(TestRunStats const& runStats) {
+ assert( isInside( Writer::Array ) );
+ // End "test-cases"
+ endArray();
+
+ {
+ auto totals =
+ m_objectWriters.top().write( "totals"_sr ).writeObject();
+ writeCounts( totals.write( "assertions"_sr ).writeObject(),
+ runStats.totals.assertions );
+ writeCounts( totals.write( "test-cases"_sr ).writeObject(),
+ runStats.totals.testCases );
+ }
+
+ // End the "test-run" object
+ endObject();
+ }
+
+ void JsonReporter::testCaseStarting( TestCaseInfo const& tcInfo ) {
+ StreamingReporterBase::testCaseStarting( tcInfo );
+
+ assert( isInside( Writer::Array ) &&
+ "We should be in the 'test-cases' array" );
+ startObject();
+ // "test-info" prelude
+ {
+ auto testInfo =
+ m_objectWriters.top().write( "test-info"_sr ).writeObject();
+ // TODO: handle testName vs className!!
+ testInfo.write( "name"_sr ).write( tcInfo.name );
+ writeSourceInfo(testInfo, tcInfo.lineInfo);
+ writeTags( testInfo.write( "tags"_sr ).writeArray(), tcInfo.tags );
+ writeProperties( testInfo.write( "properties"_sr ).writeArray(),
+ tcInfo );
+ }
+
+
+ // Start the array for individual test runs (testCasePartial pairs)
+ startArray( "runs"_sr );
+ }
+
+ void JsonReporter::testCaseEnded( TestCaseStats const& tcStats ) {
+ StreamingReporterBase::testCaseEnded( tcStats );
+
+ // We need to close the 'runs' array before finishing the test case
+ assert( isInside( Writer::Array ) );
+ endArray();
+
+ {
+ auto totals =
+ m_objectWriters.top().write( "totals"_sr ).writeObject();
+ writeCounts( totals.write( "assertions"_sr ).writeObject(),
+ tcStats.totals.assertions );
+ // We do not write the test case totals, because there will always be just one test case here.
+ // TODO: overall "result" -> success, skip, fail here? Or in partial result?
+ }
+ // We do not write out stderr/stdout, because we instead wrote those out in partial runs
+
+ // TODO: aborting?
+
+ // And we also close this test case's object
+ assert( isInside( Writer::Object ) );
+ endObject();
+ }
+
+ void JsonReporter::testCasePartialStarting( TestCaseInfo const& /*tcInfo*/,
+ uint64_t index ) {
+ startObject();
+ m_objectWriters.top().write( "run-idx"_sr ).write( index );
+ startArray( "path"_sr );
+ // TODO: we want to delay most of the printing to the 'root' section
+ // TODO: childSection key name?
+ }
+
+ void JsonReporter::testCasePartialEnded( TestCaseStats const& tcStats,
+ uint64_t /*index*/ ) {
+ // Fixme: the top level section handles this.
+ //// path object
+ endArray();
+ if ( !tcStats.stdOut.empty() ) {
+ m_objectWriters.top()
+ .write( "captured-stdout"_sr )
+ .write( tcStats.stdOut );
+ }
+ if ( !tcStats.stdErr.empty() ) {
+ m_objectWriters.top()
+ .write( "captured-stderr"_sr )
+ .write( tcStats.stdErr );
+ }
+ {
+ auto totals =
+ m_objectWriters.top().write( "totals"_sr ).writeObject();
+ writeCounts( totals.write( "assertions"_sr ).writeObject(),
+ tcStats.totals.assertions );
+ // We do not write the test case totals, because there will
+ // always be just one test case here.
+ // TODO: overall "result" -> success, skip, fail here? Or in
+ // partial result?
+ }
+ // TODO: aborting?
+ // run object
+ endObject();
+ }
+
+ void JsonReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+ assert( isInside( Writer::Array ) &&
+ "Section should always start inside an object" );
+ // We want to nest top level sections, even though it shares name
+ // and source loc with the TEST_CASE
+ auto& sectionObject = startObject();
+ sectionObject.write( "kind"_sr ).write( "section"_sr );
+ sectionObject.write( "name"_sr ).write( sectionInfo.name );
+ writeSourceInfo( m_objectWriters.top(), sectionInfo.lineInfo );
+
+
+ // TBD: Do we want to create this event lazily? It would become
+ // rather complex, but we could do it, and it would look
+ // better for empty sections. OTOH, empty sections should
+ // be rare.
+ startArray( "path"_sr );
+ }
+ void JsonReporter::sectionEnded( SectionStats const& /*sectionStats */) {
+ // End the subpath array
+ endArray();
+ // TODO: metadata
+ // TODO: what info do we have here?
+
+ // End the section object
+ endObject();
+ }
+
+ void JsonReporter::assertionStarting( AssertionInfo const& /*assertionInfo*/ ) {}
+ void JsonReporter::assertionEnded( AssertionStats const& assertionStats ) {
+ // TODO: There is lot of different things to handle here, but
+ // we can fill it in later, after we show that the basic
+ // outline and streaming reporter impl works well enough.
+ //if ( !m_config->includeSuccessfulResults()
+ // && assertionStats.assertionResult.isOk() ) {
+ // return;
+ //}
+ assert( isInside( Writer::Array ) );
+ auto assertionObject = m_arrayWriters.top().writeObject();
+
+ assertionObject.write( "kind"_sr ).write( "assertion"_sr );
+ writeSourceInfo( assertionObject,
+ assertionStats.assertionResult.getSourceInfo() );
+ assertionObject.write( "status"_sr )
+ .write( assertionStats.assertionResult.isOk() );
+ // TODO: handling of result.
+ // TODO: messages
+ // TODO: totals?
+ }
+
+
+ void JsonReporter::benchmarkPreparing( StringRef name ) { (void)name; }
+ void JsonReporter::benchmarkStarting( BenchmarkInfo const& ) {}
+ void JsonReporter::benchmarkEnded( BenchmarkStats<> const& ) {}
+ void JsonReporter::benchmarkFailed( StringRef error ) { (void)error; }
+
+ void JsonReporter::listReporters(
+ std::vector<ReporterDescription> const& descriptions ) {
+ startListing();
+
+ auto writer =
+ m_objectWriters.top().write( "reporters"_sr ).writeArray();
+ for ( auto const& desc : descriptions ) {
+ auto desc_writer = writer.writeObject();
+ desc_writer.write( "name"_sr ).write( desc.name );
+ desc_writer.write( "description"_sr ).write( desc.description );
+ }
+ }
+ void JsonReporter::listListeners(
+ std::vector<ListenerDescription> const& descriptions ) {
+ startListing();
+
+ auto writer =
+ m_objectWriters.top().write( "listeners"_sr ).writeArray();
+
+ for ( auto const& desc : descriptions ) {
+ auto desc_writer = writer.writeObject();
+ desc_writer.write( "name"_sr ).write( desc.name );
+ desc_writer.write( "description"_sr ).write( desc.description );
+ }
+ }
+ void JsonReporter::listTests( std::vector<TestCaseHandle> const& tests ) {
+ startListing();
+
+ auto writer = m_objectWriters.top().write( "tests"_sr ).writeArray();
+
+ for ( auto const& test : tests ) {
+ auto desc_writer = writer.writeObject();
+ auto const& info = test.getTestCaseInfo();
+
+ desc_writer.write( "name"_sr ).write( info.name );
+ desc_writer.write( "class-name"_sr ).write( info.className );
+ {
+ auto tag_writer = desc_writer.write( "tags"_sr ).writeArray();
+ for ( auto const& tag : info.tags ) {
+ tag_writer.write( tag.original );
+ }
+ }
+ writeSourceInfo( desc_writer, info.lineInfo );
+ }
+ }
+ void JsonReporter::listTags( std::vector<TagInfo> const& tags ) {
+ startListing();
+
+ auto writer = m_objectWriters.top().write( "tags"_sr ).writeArray();
+ for ( auto const& tag : tags ) {
+ auto tag_writer = writer.writeObject();
+ {
+ auto aliases_writer =
+ tag_writer.write( "aliases"_sr ).writeArray();
+ for ( auto alias : tag.spellings ) {
+ aliases_writer.write( alias );
+ }
+ }
+ tag_writer.write( "count"_sr ).write( tag.count );
+ }
+ }
+} // namespace Catch
+
+
+
+
+#include <cassert>
+#include <ctime>
+#include <algorithm>
+#include <iomanip>
+
+namespace Catch {
+
+ namespace {
+ std::string getCurrentTimestamp() {
+ time_t rawtime;
+ std::time(&rawtime);
+
+ std::tm timeInfo = {};
+#if defined (_MSC_VER) || defined (__MINGW32__)
+ gmtime_s(&timeInfo, &rawtime);
+#elif defined (CATCH_PLATFORM_PLAYSTATION)
+ gmtime_s(&rawtime, &timeInfo);
+#elif defined (__IAR_SYSTEMS_ICC__)
+ timeInfo = *std::gmtime(&rawtime);
+#else
+ gmtime_r(&rawtime, &timeInfo);
+#endif
+
+ auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+ char timeStamp[timeStampSize];
+ const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+ std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+
+ return std::string(timeStamp, timeStampSize - 1);
+ }
+
+ std::string fileNameTag(std::vector<Tag> const& tags) {
+ auto it = std::find_if(begin(tags),
+ end(tags),
+ [] (Tag const& tag) {
+ return tag.original.size() > 0
+ && tag.original[0] == '#'; });
+ if (it != tags.end()) {
+ return static_cast<std::string>(
+ it->original.substr(1, it->original.size() - 1)
+ );
+ }
+ return std::string();
+ }
+
+ // Formats the duration in seconds to 3 decimal places.
+ // This is done because some genius defined Maven Surefire schema
+ // in a way that only accepts 3 decimal places, and tools like
+ // Jenkins use that schema for validation JUnit reporter output.
+ std::string formatDuration( double seconds ) {
+ ReusableStringStream rss;
+ rss << std::fixed << std::setprecision( 3 ) << seconds;
+ return rss.str();
+ }
+
+ static void normalizeNamespaceMarkers(std::string& str) {
+ std::size_t pos = str.find( "::" );
+ while ( pos != std::string::npos ) {
+ str.replace( pos, 2, "." );
+ pos += 1;
+ pos = str.find( "::", pos );
+ }
+ }
+
+ } // anonymous namespace
+
+ JunitReporter::JunitReporter( ReporterConfig&& _config )
+ : CumulativeReporterBase( CATCH_MOVE(_config) ),
+ xml( m_stream )
+ {
+ m_preferences.shouldRedirectStdOut = true;
+ m_preferences.shouldReportAllAssertions = true;
+ m_shouldStoreSuccesfulAssertions = false;
+ }
+
+ std::string JunitReporter::getDescription() {
+ return "Reports test results in an XML format that looks like Ant's junitreport target";
+ }
+
+ void JunitReporter::testRunStarting( TestRunInfo const& runInfo ) {
+ CumulativeReporterBase::testRunStarting( runInfo );
+ xml.startElement( "testsuites" );
+ suiteTimer.start();
+ stdOutForSuite.clear();
+ stdErrForSuite.clear();
+ unexpectedExceptions = 0;
+ }
+
+ void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
+ m_okToFail = testCaseInfo.okToFail();
+ }
+
+ void JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
+ if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+ unexpectedExceptions++;
+ CumulativeReporterBase::assertionEnded( assertionStats );
+ }
+
+ void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+ stdOutForSuite += testCaseStats.stdOut;
+ stdErrForSuite += testCaseStats.stdErr;
+ CumulativeReporterBase::testCaseEnded( testCaseStats );
+ }
+
+ void JunitReporter::testRunEndedCumulative() {
+ const auto suiteTime = suiteTimer.getElapsedSeconds();
+ writeRun( *m_testRun, suiteTime );
+ xml.endElement();
+ }
+
+ void JunitReporter::writeRun( TestRunNode const& testRunNode, double suiteTime ) {
+ XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+
+ TestRunStats const& stats = testRunNode.value;
+ xml.writeAttribute( "name"_sr, stats.runInfo.name );
+ xml.writeAttribute( "errors"_sr, unexpectedExceptions );
+ xml.writeAttribute( "failures"_sr, stats.totals.assertions.failed-unexpectedExceptions );
+ xml.writeAttribute( "skipped"_sr, stats.totals.assertions.skipped );
+ xml.writeAttribute( "tests"_sr, stats.totals.assertions.total() );
+ xml.writeAttribute( "hostname"_sr, "tbd"_sr ); // !TBD
+ if( m_config->showDurations() == ShowDurations::Never )
+ xml.writeAttribute( "time"_sr, ""_sr );
+ else
+ xml.writeAttribute( "time"_sr, formatDuration( suiteTime ) );
+ xml.writeAttribute( "timestamp"_sr, getCurrentTimestamp() );
+
+ // Write properties
+ {
+ auto properties = xml.scopedElement("properties");
+ xml.scopedElement("property")
+ .writeAttribute("name"_sr, "random-seed"_sr)
+ .writeAttribute("value"_sr, m_config->rngSeed());
+ if (m_config->testSpec().hasFilters()) {
+ xml.scopedElement("property")
+ .writeAttribute("name"_sr, "filters"_sr)
+ .writeAttribute("value"_sr, m_config->testSpec());
+ }
+ }
+
+ // Write test cases
+ for( auto const& child : testRunNode.children )
+ writeTestCase( *child );
+
+ xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
+ xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
+ }
+
+ void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
+ TestCaseStats const& stats = testCaseNode.value;
+
+ // All test cases have exactly one section - which represents the
+ // test case itself. That section may have 0-n nested sections
+ assert( testCaseNode.children.size() == 1 );
+ SectionNode const& rootSection = *testCaseNode.children.front();
+
+ std::string className =
+ static_cast<std::string>( stats.testInfo->className );
+
+ if( className.empty() ) {
+ className = fileNameTag(stats.testInfo->tags);
+ if ( className.empty() ) {
+ className = "global";
+ }
+ }
+
+ if ( !m_config->name().empty() )
+ className = static_cast<std::string>(m_config->name()) + '.' + className;
+
+ normalizeNamespaceMarkers(className);
+
+ writeSection( className, "", rootSection, stats.testInfo->okToFail() );
+ }
+
+ void JunitReporter::writeSection( std::string const& className,
+ std::string const& rootName,
+ SectionNode const& sectionNode,
+ bool testOkToFail) {
+ std::string name = trim( sectionNode.stats.sectionInfo.name );
+ if( !rootName.empty() )
+ name = rootName + '/' + name;
+
+ if( sectionNode.hasAnyAssertions()
+ || !sectionNode.stdOut.empty()
+ || !sectionNode.stdErr.empty() ) {
+ XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+ if( className.empty() ) {
+ xml.writeAttribute( "classname"_sr, name );
+ xml.writeAttribute( "name"_sr, "root"_sr );
+ }
+ else {
+ xml.writeAttribute( "classname"_sr, className );
+ xml.writeAttribute( "name"_sr, name );
+ }
+ xml.writeAttribute( "time"_sr, formatDuration( sectionNode.stats.durationInSeconds ) );
+ // This is not ideal, but it should be enough to mimic gtest's
+ // junit output.
+ // Ideally the JUnit reporter would also handle `skipTest`
+ // events and write those out appropriately.
+ xml.writeAttribute( "status"_sr, "run"_sr );
+
+ if (sectionNode.stats.assertions.failedButOk) {
+ xml.scopedElement("skipped")
+ .writeAttribute("message", "TEST_CASE tagged with !mayfail");
+ }
+
+ writeAssertions( sectionNode );
+
+
+ if( !sectionNode.stdOut.empty() )
+ xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
+ if( !sectionNode.stdErr.empty() )
+ xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
+ }
+ for( auto const& childNode : sectionNode.childSections )
+ if( className.empty() )
+ writeSection( name, "", *childNode, testOkToFail );
+ else
+ writeSection( className, name, *childNode, testOkToFail );
+ }
+
+ void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
+ for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
+ if (assertionOrBenchmark.isAssertion()) {
+ writeAssertion(assertionOrBenchmark.asAssertion());
+ }
+ }
+ }
+
+ void JunitReporter::writeAssertion( AssertionStats const& stats ) {
+ AssertionResult const& result = stats.assertionResult;
+ if ( !result.isOk() ||
+ result.getResultType() == ResultWas::ExplicitSkip ) {
+ std::string elementName;
+ switch( result.getResultType() ) {
+ case ResultWas::ThrewException:
+ case ResultWas::FatalErrorCondition:
+ elementName = "error";
+ break;
+ case ResultWas::ExplicitFailure:
+ case ResultWas::ExpressionFailed:
+ case ResultWas::DidntThrowException:
+ elementName = "failure";
+ break;
+ case ResultWas::ExplicitSkip:
+ elementName = "skipped";
+ break;
+ // We should never see these here:
+ case ResultWas::Info:
+ case ResultWas::Warning:
+ case ResultWas::Ok:
+ case ResultWas::Unknown:
+ case ResultWas::FailureBit:
+ case ResultWas::Exception:
+ elementName = "internalError";
+ break;
+ }
+
+ XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+ xml.writeAttribute( "message"_sr, result.getExpression() );
+ xml.writeAttribute( "type"_sr, result.getTestMacroName() );
+
+ ReusableStringStream rss;
+ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+ rss << "SKIPPED\n";
+ } else {
+ rss << "FAILED" << ":\n";
+ if (result.hasExpression()) {
+ rss << " ";
+ rss << result.getExpressionInMacro();
+ rss << '\n';
+ }
+ if (result.hasExpandedExpression()) {
+ rss << "with expansion:\n";
+ rss << TextFlow::Column(result.getExpandedExpression()).indent(2) << '\n';
+ }
+ }
+
+ if( result.hasMessage() )
+ rss << result.getMessage() << '\n';
+ for( auto const& msg : stats.infoMessages )
+ if( msg.type == ResultWas::Info )
+ rss << msg.message << '\n';
+
+ rss << "at " << result.getSourceInfo();
+ xml.writeText( rss.str(), XmlFormatting::Newline );
+ }
+ }
+
+} // end namespace Catch
+
+
+
+
+#include <ostream>
+
+namespace Catch {
+ void MultiReporter::updatePreferences(IEventListener const& reporterish) {
+ m_preferences.shouldRedirectStdOut |=
+ reporterish.getPreferences().shouldRedirectStdOut;
+ m_preferences.shouldReportAllAssertions |=
+ reporterish.getPreferences().shouldReportAllAssertions;
+ }
+
+ void MultiReporter::addListener( IEventListenerPtr&& listener ) {
+ updatePreferences(*listener);
+ m_reporterLikes.insert(m_reporterLikes.begin() + m_insertedListeners, CATCH_MOVE(listener) );
+ ++m_insertedListeners;
+ }
+
+ void MultiReporter::addReporter( IEventListenerPtr&& reporter ) {
+ updatePreferences(*reporter);
+
+ // We will need to output the captured stdout if there are reporters
+ // that do not want it captured.
+ // We do not consider listeners, because it is generally assumed that
+ // listeners are output-transparent, even though they can ask for stdout
+ // capture to do something with it.
+ m_haveNoncapturingReporters |= !reporter->getPreferences().shouldRedirectStdOut;
+
+ // Reporters can always be placed to the back without breaking the
+ // reporting order
+ m_reporterLikes.push_back( CATCH_MOVE( reporter ) );
+ }
+
+ void MultiReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->noMatchingTestCases( unmatchedSpec );
+ }
+ }
+
+ void MultiReporter::fatalErrorEncountered( StringRef error ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->fatalErrorEncountered( error );
+ }
+ }
+
+ void MultiReporter::reportInvalidTestSpec( StringRef arg ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->reportInvalidTestSpec( arg );
+ }
+ }
+
+ void MultiReporter::benchmarkPreparing( StringRef name ) {
+ for (auto& reporterish : m_reporterLikes) {
+ reporterish->benchmarkPreparing(name);
+ }
+ }
+ void MultiReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->benchmarkStarting( benchmarkInfo );
+ }
+ }
+ void MultiReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->benchmarkEnded( benchmarkStats );
+ }
+ }
+
+ void MultiReporter::benchmarkFailed( StringRef error ) {
+ for (auto& reporterish : m_reporterLikes) {
+ reporterish->benchmarkFailed(error);
+ }
+ }
+
+ void MultiReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->testRunStarting( testRunInfo );
+ }
+ }
+
+ void MultiReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->testCaseStarting( testInfo );
+ }
+ }
+
+ void
+ MultiReporter::testCasePartialStarting( TestCaseInfo const& testInfo,
+ uint64_t partNumber ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->testCasePartialStarting( testInfo, partNumber );
+ }
+ }
+
+ void MultiReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->sectionStarting( sectionInfo );
+ }
+ }
+
+ void MultiReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->assertionStarting( assertionInfo );
+ }
+ }
+
+ void MultiReporter::assertionEnded( AssertionStats const& assertionStats ) {
+ const bool reportByDefault =
+ assertionStats.assertionResult.getResultType() != ResultWas::Ok ||
+ m_config->includeSuccessfulResults();
+
+ for ( auto & reporterish : m_reporterLikes ) {
+ if ( reportByDefault ||
+ reporterish->getPreferences().shouldReportAllAssertions ) {
+ reporterish->assertionEnded( assertionStats );
+ }
+ }
+ }
+
+ void MultiReporter::sectionEnded( SectionStats const& sectionStats ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->sectionEnded( sectionStats );
+ }
+ }
+
+ void MultiReporter::testCasePartialEnded( TestCaseStats const& testStats,
+ uint64_t partNumber ) {
+ if ( m_preferences.shouldRedirectStdOut &&
+ m_haveNoncapturingReporters ) {
+ if ( !testStats.stdOut.empty() ) {
+ Catch::cout() << testStats.stdOut << std::flush;
+ }
+ if ( !testStats.stdErr.empty() ) {
+ Catch::cerr() << testStats.stdErr << std::flush;
+ }
+ }
+
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->testCasePartialEnded( testStats, partNumber );
+ }
+ }
+
+ void MultiReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->testCaseEnded( testCaseStats );
+ }
+ }
+
+ void MultiReporter::testRunEnded( TestRunStats const& testRunStats ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->testRunEnded( testRunStats );
+ }
+ }
+
+
+ void MultiReporter::skipTest( TestCaseInfo const& testInfo ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->skipTest( testInfo );
+ }
+ }
+
+ void MultiReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
+ for (auto& reporterish : m_reporterLikes) {
+ reporterish->listReporters(descriptions);
+ }
+ }
+
+ void MultiReporter::listListeners(
+ std::vector<ListenerDescription> const& descriptions ) {
+ for ( auto& reporterish : m_reporterLikes ) {
+ reporterish->listListeners( descriptions );
+ }
+ }
+
+ void MultiReporter::listTests(std::vector<TestCaseHandle> const& tests) {
+ for (auto& reporterish : m_reporterLikes) {
+ reporterish->listTests(tests);
+ }
+ }
+
+ void MultiReporter::listTags(std::vector<TagInfo> const& tags) {
+ for (auto& reporterish : m_reporterLikes) {
+ reporterish->listTags(tags);
+ }
+ }
+
+} // end namespace Catch
+
+
+
+
+
+namespace Catch {
+ namespace Detail {
+
+ void registerReporterImpl( std::string const& name,
+ IReporterFactoryPtr reporterPtr ) {
+ CATCH_TRY {
+ getMutableRegistryHub().registerReporter(
+ name, CATCH_MOVE( reporterPtr ) );
+ }
+ CATCH_CATCH_ALL {
+ // Do not throw when constructing global objects, instead
+ // register the exception to be processed later
+ getMutableRegistryHub().registerStartupException();
+ }
+ }
+
+ void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory ) {
+ getMutableRegistryHub().registerListener( CATCH_MOVE(listenerFactory) );
+ }
+
+
+ } // namespace Detail
+} // namespace Catch
+
+
+
+
+#include <map>
+
+namespace Catch {
+
+ namespace {
+ std::string createMetadataString(IConfig const& config) {
+ ReusableStringStream sstr;
+ if ( config.testSpec().hasFilters() ) {
+ sstr << "filters='"
+ << config.testSpec()
+ << "' ";
+ }
+ sstr << "rng-seed=" << config.rngSeed();
+ return sstr.str();
+ }
+ }
+
+ void SonarQubeReporter::testRunStarting(TestRunInfo const& testRunInfo) {
+ CumulativeReporterBase::testRunStarting(testRunInfo);
+
+ xml.writeComment( createMetadataString( *m_config ) );
+ xml.startElement("testExecutions");
+ xml.writeAttribute("version"_sr, '1');
+ }
+
+ void SonarQubeReporter::writeRun( TestRunNode const& runNode ) {
+ std::map<StringRef, std::vector<TestCaseNode const*>> testsPerFile;
+
+ for ( auto const& child : runNode.children ) {
+ testsPerFile[child->value.testInfo->lineInfo.file].push_back(
+ child.get() );
+ }
+
+ for ( auto const& kv : testsPerFile ) {
+ writeTestFile( kv.first, kv.second );
+ }
+ }
+
+ void SonarQubeReporter::writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
+ XmlWriter::ScopedElement e = xml.scopedElement("file");
+ xml.writeAttribute("path"_sr, filename);
+
+ for (auto const& child : testCaseNodes)
+ writeTestCase(*child);
+ }
+
+ void SonarQubeReporter::writeTestCase(TestCaseNode const& testCaseNode) {
+ // All test cases have exactly one section - which represents the
+ // test case itself. That section may have 0-n nested sections
+ assert(testCaseNode.children.size() == 1);
+ SectionNode const& rootSection = *testCaseNode.children.front();
+ writeSection("", rootSection, testCaseNode.value.testInfo->okToFail());
+ }
+
+ void SonarQubeReporter::writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
+ std::string name = trim(sectionNode.stats.sectionInfo.name);
+ if (!rootName.empty())
+ name = rootName + '/' + name;
+
+ if ( sectionNode.hasAnyAssertions()
+ || !sectionNode.stdOut.empty()
+ || !sectionNode.stdErr.empty() ) {
+ XmlWriter::ScopedElement e = xml.scopedElement("testCase");
+ xml.writeAttribute("name"_sr, name);
+ xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
+
+ writeAssertions(sectionNode, okToFail);
+ }
+
+ for (auto const& childNode : sectionNode.childSections)
+ writeSection(name, *childNode, okToFail);
+ }
+
+ void SonarQubeReporter::writeAssertions(SectionNode const& sectionNode, bool okToFail) {
+ for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
+ if (assertionOrBenchmark.isAssertion()) {
+ writeAssertion(assertionOrBenchmark.asAssertion(), okToFail);
+ }
+ }
+ }
+
+ void SonarQubeReporter::writeAssertion(AssertionStats const& stats, bool okToFail) {
+ AssertionResult const& result = stats.assertionResult;
+ if ( !result.isOk() ||
+ result.getResultType() == ResultWas::ExplicitSkip ) {
+ std::string elementName;
+ if (okToFail) {
+ elementName = "skipped";
+ } else {
+ switch (result.getResultType()) {
+ case ResultWas::ThrewException:
+ case ResultWas::FatalErrorCondition:
+ elementName = "error";
+ break;
+ case ResultWas::ExplicitFailure:
+ case ResultWas::ExpressionFailed:
+ case ResultWas::DidntThrowException:
+ elementName = "failure";
+ break;
+ case ResultWas::ExplicitSkip:
+ elementName = "skipped";
+ break;
+ // We should never see these here:
+ case ResultWas::Info:
+ case ResultWas::Warning:
+ case ResultWas::Ok:
+ case ResultWas::Unknown:
+ case ResultWas::FailureBit:
+ case ResultWas::Exception:
+ elementName = "internalError";
+ break;
+ }
+ }
+
+ XmlWriter::ScopedElement e = xml.scopedElement(elementName);
+
+ ReusableStringStream messageRss;
+ messageRss << result.getTestMacroName() << '(' << result.getExpression() << ')';
+ xml.writeAttribute("message"_sr, messageRss.str());
+
+ ReusableStringStream textRss;
+ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+ textRss << "SKIPPED\n";
+ } else {
+ textRss << "FAILED:\n";
+ if (result.hasExpression()) {
+ textRss << '\t' << result.getExpressionInMacro() << '\n';
+ }
+ if (result.hasExpandedExpression()) {
+ textRss << "with expansion:\n\t" << result.getExpandedExpression() << '\n';
+ }
+ }
+
+ if (result.hasMessage())
+ textRss << result.getMessage() << '\n';
+
+ for (auto const& msg : stats.infoMessages)
+ if (msg.type == ResultWas::Info)
+ textRss << msg.message << '\n';
+
+ textRss << "at " << result.getSourceInfo();
+ xml.writeText(textRss.str(), XmlFormatting::Newline);
+ }
+ }
+
+} // end namespace Catch
+
+
+
+namespace Catch {
+
+ StreamingReporterBase::~StreamingReporterBase() = default;
+
+ void
+ StreamingReporterBase::testRunStarting( TestRunInfo const& _testRunInfo ) {
+ currentTestRunInfo = _testRunInfo;
+ }
+
+ void StreamingReporterBase::testRunEnded( TestRunStats const& ) {
+ currentTestCaseInfo = nullptr;
+ }
+
+} // end namespace Catch
+
+
+
+#include <algorithm>
+#include <ostream>
+
+namespace Catch {
+
+ namespace {
+ // Yes, this has to be outside the class and namespaced by naming.
+ // Making older compiler happy is hard.
+ static constexpr StringRef tapFailedString = "not ok"_sr;
+ static constexpr StringRef tapPassedString = "ok"_sr;
+ static constexpr Colour::Code tapDimColour = Colour::FileName;
+
+ class TapAssertionPrinter {
+ public:
+ TapAssertionPrinter& operator= (TapAssertionPrinter const&) = delete;
+ TapAssertionPrinter(TapAssertionPrinter const&) = delete;
+ TapAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter, ColourImpl* colour_)
+ : stream(_stream)
+ , result(_stats.assertionResult)
+ , messages(_stats.infoMessages)
+ , itMessage(_stats.infoMessages.begin())
+ , printInfoMessages(true)
+ , counter(_counter)
+ , colourImpl( colour_ ) {}
+
+ void print() {
+ itMessage = messages.begin();
+
+ switch (result.getResultType()) {
+ case ResultWas::Ok:
+ printResultType(tapPassedString);
+ printOriginalExpression();
+ printReconstructedExpression();
+ if (!result.hasExpression())
+ printRemainingMessages(Colour::None);
+ else
+ printRemainingMessages();
+ break;
+ case ResultWas::ExpressionFailed:
+ if (result.isOk()) {
+ printResultType(tapPassedString);
+ } else {
+ printResultType(tapFailedString);
+ }
+ printOriginalExpression();
+ printReconstructedExpression();
+ if (result.isOk()) {
+ printIssue(" # TODO");
+ }
+ printRemainingMessages();
+ break;
+ case ResultWas::ThrewException:
+ printResultType(tapFailedString);
+ printIssue("unexpected exception with message:"_sr);
+ printMessage();
+ printExpressionWas();
+ printRemainingMessages();
+ break;
+ case ResultWas::FatalErrorCondition:
+ printResultType(tapFailedString);
+ printIssue("fatal error condition with message:"_sr);
+ printMessage();
+ printExpressionWas();
+ printRemainingMessages();
+ break;
+ case ResultWas::DidntThrowException:
+ printResultType(tapFailedString);
+ printIssue("expected exception, got none"_sr);
+ printExpressionWas();
+ printRemainingMessages();
+ break;
+ case ResultWas::Info:
+ printResultType("info"_sr);
+ printMessage();
+ printRemainingMessages();
+ break;
+ case ResultWas::Warning:
+ printResultType("warning"_sr);
+ printMessage();
+ printRemainingMessages();
+ break;
+ case ResultWas::ExplicitFailure:
+ printResultType(tapFailedString);
+ printIssue("explicitly"_sr);
+ printRemainingMessages(Colour::None);
+ break;
+ case ResultWas::ExplicitSkip:
+ printResultType(tapPassedString);
+ printIssue(" # SKIP"_sr);
+ printMessage();
+ printRemainingMessages();
+ break;
+ // These cases are here to prevent compiler warnings
+ case ResultWas::Unknown:
+ case ResultWas::FailureBit:
+ case ResultWas::Exception:
+ printResultType("** internal error **"_sr);
+ break;
+ }
+ }
+
+ private:
+ void printResultType(StringRef passOrFail) const {
+ if (!passOrFail.empty()) {
+ stream << passOrFail << ' ' << counter << " -";
+ }
+ }
+
+ void printIssue(StringRef issue) const {
+ stream << ' ' << issue;
+ }
+
+ void printExpressionWas() {
+ if (result.hasExpression()) {
+ stream << ';';
+ stream << colourImpl->guardColour( tapDimColour )
+ << " expression was:";
+ printOriginalExpression();
+ }
+ }
+
+ void printOriginalExpression() const {
+ if (result.hasExpression()) {
+ stream << ' ' << result.getExpression();
+ }
+ }
+
+ void printReconstructedExpression() const {
+ if (result.hasExpandedExpression()) {
+ stream << colourImpl->guardColour( tapDimColour ) << " for: ";
+
+ std::string expr = result.getExpandedExpression();
+ std::replace(expr.begin(), expr.end(), '\n', ' ');
+ stream << expr;
+ }
+ }
+
+ void printMessage() {
+ if (itMessage != messages.end()) {
+ stream << " '" << itMessage->message << '\'';
+ ++itMessage;
+ }
+ }
+
+ void printRemainingMessages(Colour::Code colour = tapDimColour) {
+ if (itMessage == messages.end()) {
+ return;
+ }
+
+ // using messages.end() directly (or auto) yields compilation error:
+ std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+ const std::size_t N = static_cast<std::size_t>(itEnd - itMessage);
+
+ stream << colourImpl->guardColour( colour ) << " with "
+ << pluralise( N, "message"_sr ) << ':';
+
+ for (; itMessage != itEnd; ) {
+ // If this assertion is a warning ignore any INFO messages
+ if (printInfoMessages || itMessage->type != ResultWas::Info) {
+ stream << " '" << itMessage->message << '\'';
+ if (++itMessage != itEnd) {
+ stream << colourImpl->guardColour(tapDimColour) << " and";
+ }
+ }
+ }
+ }
+
+ private:
+ std::ostream& stream;
+ AssertionResult const& result;
+ std::vector<MessageInfo> const& messages;
+ std::vector<MessageInfo>::const_iterator itMessage;
+ bool printInfoMessages;
+ std::size_t counter;
+ ColourImpl* colourImpl;
+ };
+
+ } // End anonymous namespace
+
+ void TAPReporter::testRunStarting( TestRunInfo const& ) {
+ if ( m_config->testSpec().hasFilters() ) {
+ m_stream << "# filters: " << m_config->testSpec() << '\n';
+ }
+ m_stream << "# rng-seed: " << m_config->rngSeed() << '\n';
+ }
+
+ void TAPReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+ m_stream << "# No test cases matched '" << unmatchedSpec << "'\n";
+ }
+
+ void TAPReporter::assertionEnded(AssertionStats const& _assertionStats) {
+ ++counter;
+
+ m_stream << "# " << currentTestCaseInfo->name << '\n';
+ TapAssertionPrinter printer(m_stream, _assertionStats, counter, m_colour.get());
+ printer.print();
+
+ m_stream << '\n' << std::flush;
+ }
+
+ void TAPReporter::testRunEnded(TestRunStats const& _testRunStats) {
+ m_stream << "1.." << _testRunStats.totals.assertions.total();
+ if (_testRunStats.totals.testCases.total() == 0) {
+ m_stream << " # Skipped: No tests ran.";
+ }
+ m_stream << "\n\n" << std::flush;
+ StreamingReporterBase::testRunEnded(_testRunStats);
+ }
+
+
+
+
+} // end namespace Catch
+
+
+
+
+#include <cassert>
+#include <ostream>
+
+namespace Catch {
+
+ namespace {
+ // if string has a : in first line will set indent to follow it on
+ // subsequent lines
+ void printHeaderString(std::ostream& os, std::string const& _string, std::size_t indent = 0) {
+ std::size_t i = _string.find(": ");
+ if (i != std::string::npos)
+ i += 2;
+ else
+ i = 0;
+ os << TextFlow::Column(_string)
+ .indent(indent + i)
+ .initialIndent(indent) << '\n';
+ }
+
+ std::string escape(StringRef str) {
+ std::string escaped = static_cast<std::string>(str);
+ replaceInPlace(escaped, "|", "||");
+ replaceInPlace(escaped, "'", "|'");
+ replaceInPlace(escaped, "\n", "|n");
+ replaceInPlace(escaped, "\r", "|r");
+ replaceInPlace(escaped, "[", "|[");
+ replaceInPlace(escaped, "]", "|]");
+ return escaped;
+ }
+ } // end anonymous namespace
+
+
+ TeamCityReporter::~TeamCityReporter() = default;
+
+ void TeamCityReporter::testRunStarting( TestRunInfo const& runInfo ) {
+ m_stream << "##teamcity[testSuiteStarted name='" << escape( runInfo.name )
+ << "']\n";
+ }
+
+ void TeamCityReporter::testRunEnded( TestRunStats const& runStats ) {
+ m_stream << "##teamcity[testSuiteFinished name='"
+ << escape( runStats.runInfo.name ) << "']\n";
+ }
+
+ void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) {
+ AssertionResult const& result = assertionStats.assertionResult;
+ if ( !result.isOk() ||
+ result.getResultType() == ResultWas::ExplicitSkip ) {
+
+ ReusableStringStream msg;
+ if (!m_headerPrintedForThisSection)
+ printSectionHeader(msg.get());
+ m_headerPrintedForThisSection = true;
+
+ msg << result.getSourceInfo() << '\n';
+
+ switch (result.getResultType()) {
+ case ResultWas::ExpressionFailed:
+ msg << "expression failed";
+ break;
+ case ResultWas::ThrewException:
+ msg << "unexpected exception";
+ break;
+ case ResultWas::FatalErrorCondition:
+ msg << "fatal error condition";
+ break;
+ case ResultWas::DidntThrowException:
+ msg << "no exception was thrown where one was expected";
+ break;
+ case ResultWas::ExplicitFailure:
+ msg << "explicit failure";
+ break;
+ case ResultWas::ExplicitSkip:
+ msg << "explicit skip";
+ break;
+
+ // We shouldn't get here because of the isOk() test
+ case ResultWas::Ok:
+ case ResultWas::Info:
+ case ResultWas::Warning:
+ CATCH_ERROR("Internal error in TeamCity reporter");
+ // These cases are here to prevent compiler warnings
+ case ResultWas::Unknown:
+ case ResultWas::FailureBit:
+ case ResultWas::Exception:
+ CATCH_ERROR("Not implemented");
+ }
+ if (assertionStats.infoMessages.size() == 1)
+ msg << " with message:";
+ if (assertionStats.infoMessages.size() > 1)
+ msg << " with messages:";
+ for (auto const& messageInfo : assertionStats.infoMessages)
+ msg << "\n \"" << messageInfo.message << '"';
+
+
+ if (result.hasExpression()) {
+ msg <<
+ "\n " << result.getExpressionInMacro() << "\n"
+ "with expansion:\n"
+ " " << result.getExpandedExpression() << '\n';
+ }
+
+ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+ m_stream << "##teamcity[testIgnored";
+ } else if ( currentTestCaseInfo->okToFail() ) {
+ msg << "- failure ignore as test marked as 'ok to fail'\n";
+ m_stream << "##teamcity[testIgnored";
+ } else {
+ m_stream << "##teamcity[testFailed";
+ }
+ m_stream << " name='" << escape( currentTestCaseInfo->name ) << '\''
+ << " message='" << escape( msg.str() ) << '\'' << "]\n";
+ }
+ m_stream.flush();
+ }
+
+ void TeamCityReporter::testCaseStarting(TestCaseInfo const& testInfo) {
+ m_testTimer.start();
+ StreamingReporterBase::testCaseStarting(testInfo);
+ m_stream << "##teamcity[testStarted name='"
+ << escape(testInfo.name) << "']\n";
+ m_stream.flush();
+ }
+
+ void TeamCityReporter::testCaseEnded(TestCaseStats const& testCaseStats) {
+ StreamingReporterBase::testCaseEnded(testCaseStats);
+ auto const& testCaseInfo = *testCaseStats.testInfo;
+ if (!testCaseStats.stdOut.empty())
+ m_stream << "##teamcity[testStdOut name='"
+ << escape(testCaseInfo.name)
+ << "' out='" << escape(testCaseStats.stdOut) << "']\n";
+ if (!testCaseStats.stdErr.empty())
+ m_stream << "##teamcity[testStdErr name='"
+ << escape(testCaseInfo.name)
+ << "' out='" << escape(testCaseStats.stdErr) << "']\n";
+ m_stream << "##teamcity[testFinished name='"
+ << escape(testCaseInfo.name) << "' duration='"
+ << m_testTimer.getElapsedMilliseconds() << "']\n";
+ m_stream.flush();
+ }
+
+ void TeamCityReporter::printSectionHeader(std::ostream& os) {
+ assert(!m_sectionStack.empty());
+
+ if (m_sectionStack.size() > 1) {
+ os << lineOfChars('-') << '\n';
+
+ std::vector<SectionInfo>::const_iterator
+ it = m_sectionStack.begin() + 1, // Skip first section (test case)
+ itEnd = m_sectionStack.end();
+ for (; it != itEnd; ++it)
+ printHeaderString(os, it->name);
+ os << lineOfChars('-') << '\n';
+ }
+
+ SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+
+ os << lineInfo << '\n';
+ os << lineOfChars('.') << "\n\n";
+ }
+
+} // end namespace Catch
+
+
+
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+ // Note that 4062 (not all labels are handled
+ // and default is missing) is enabled
+#endif
+
+namespace Catch {
+ XmlReporter::XmlReporter( ReporterConfig&& _config )
+ : StreamingReporterBase( CATCH_MOVE(_config) ),
+ m_xml(m_stream)
+ {
+ m_preferences.shouldRedirectStdOut = true;
+ m_preferences.shouldReportAllAssertions = true;
+ }
+
+ XmlReporter::~XmlReporter() = default;
+
+ std::string XmlReporter::getDescription() {
+ return "Reports test results as an XML document";
+ }
+
+ std::string XmlReporter::getStylesheetRef() const {
+ return std::string();
+ }
+
+ void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+ m_xml
+ .writeAttribute( "filename"_sr, sourceInfo.file )
+ .writeAttribute( "line"_sr, sourceInfo.line );
+ }
+
+ void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
+ StreamingReporterBase::testRunStarting( testInfo );
+ std::string stylesheetRef = getStylesheetRef();
+ if( !stylesheetRef.empty() )
+ m_xml.writeStylesheetRef( stylesheetRef );
+ m_xml.startElement("Catch2TestRun")
+ .writeAttribute("name"_sr, m_config->name())
+ .writeAttribute("rng-seed"_sr, m_config->rngSeed())
+ .writeAttribute("xml-format-version"_sr, 3)
+ .writeAttribute("catch2-version"_sr, libraryVersion());
+ if ( m_config->testSpec().hasFilters() ) {
+ m_xml.writeAttribute( "filters"_sr, m_config->testSpec() );
+ }
+ }
+
+ void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+ StreamingReporterBase::testCaseStarting(testInfo);
+ m_xml.startElement( "TestCase" )
+ .writeAttribute( "name"_sr, trim( StringRef(testInfo.name) ) )
+ .writeAttribute( "tags"_sr, testInfo.tagsAsString() );
+
+ writeSourceInfo( testInfo.lineInfo );
+
+ if ( m_config->showDurations() == ShowDurations::Always )
+ m_testCaseTimer.start();
+ m_xml.ensureTagClosed();
+ }
+
+ void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+ StreamingReporterBase::sectionStarting( sectionInfo );
+ if( m_sectionDepth++ > 0 ) {
+ m_xml.startElement( "Section" )
+ .writeAttribute( "name"_sr, trim( StringRef(sectionInfo.name) ) );
+ writeSourceInfo( sectionInfo.lineInfo );
+ m_xml.ensureTagClosed();
+ }
+ }
+
+ void XmlReporter::assertionStarting( AssertionInfo const& ) { }
+
+ void XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
+
+ AssertionResult const& result = assertionStats.assertionResult;
+
+ bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+ if( includeResults || result.getResultType() == ResultWas::Warning ) {
+ // Print any info messages in <Info> tags.
+ for( auto const& msg : assertionStats.infoMessages ) {
+ if( msg.type == ResultWas::Info && includeResults ) {
+ auto t = m_xml.scopedElement( "Info" );
+ writeSourceInfo( msg.lineInfo );
+ t.writeText( msg.message );
+ } else if ( msg.type == ResultWas::Warning ) {
+ auto t = m_xml.scopedElement( "Warning" );
+ writeSourceInfo( msg.lineInfo );
+ t.writeText( msg.message );
+ }
+ }
+ }
+
+ // Drop out if result was successful but we're not printing them.
+ if ( !includeResults && result.getResultType() != ResultWas::Warning &&
+ result.getResultType() != ResultWas::ExplicitSkip ) {
+ return;
+ }
+
+ // Print the expression if there is one.
+ if( result.hasExpression() ) {
+ m_xml.startElement( "Expression" )
+ .writeAttribute( "success"_sr, result.succeeded() )
+ .writeAttribute( "type"_sr, result.getTestMacroName() );
+
+ writeSourceInfo( result.getSourceInfo() );
+
+ m_xml.scopedElement( "Original" )
+ .writeText( result.getExpression() );
+ m_xml.scopedElement( "Expanded" )
+ .writeText( result.getExpandedExpression() );
+ }
+
+ // And... Print a result applicable to each result type.
+ switch( result.getResultType() ) {
+ case ResultWas::ThrewException:
+ m_xml.startElement( "Exception" );
+ writeSourceInfo( result.getSourceInfo() );
+ m_xml.writeText( result.getMessage() );
+ m_xml.endElement();
+ break;
+ case ResultWas::FatalErrorCondition:
+ m_xml.startElement( "FatalErrorCondition" );
+ writeSourceInfo( result.getSourceInfo() );
+ m_xml.writeText( result.getMessage() );
+ m_xml.endElement();
+ break;
+ case ResultWas::Info:
+ m_xml.scopedElement( "Info" )
+ .writeText( result.getMessage() );
+ break;
+ case ResultWas::Warning:
+ // Warning will already have been written
+ break;
+ case ResultWas::ExplicitFailure:
+ m_xml.startElement( "Failure" );
+ writeSourceInfo( result.getSourceInfo() );
+ m_xml.writeText( result.getMessage() );
+ m_xml.endElement();
+ break;
+ case ResultWas::ExplicitSkip:
+ m_xml.startElement( "Skip" );
+ writeSourceInfo( result.getSourceInfo() );
+ m_xml.writeText( result.getMessage() );
+ m_xml.endElement();
+ break;
+ default:
+ break;
+ }
+
+ if( result.hasExpression() )
+ m_xml.endElement();
+ }
+
+ void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
+ StreamingReporterBase::sectionEnded( sectionStats );
+ if ( --m_sectionDepth > 0 ) {
+ {
+ XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+ e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
+ e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
+ e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
+ e.writeAttribute( "skipped"_sr, sectionStats.assertions.skipped > 0 );
+
+ if ( m_config->showDurations() == ShowDurations::Always )
+ e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
+ }
+ // Ends assertion tag
+ m_xml.endElement();
+ }
+ }
+
+ void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+ StreamingReporterBase::testCaseEnded( testCaseStats );
+ XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+ e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() );
+ e.writeAttribute( "skips"_sr, testCaseStats.totals.assertions.skipped );
+
+ if ( m_config->showDurations() == ShowDurations::Always )
+ e.writeAttribute( "durationInSeconds"_sr, m_testCaseTimer.getElapsedSeconds() );
+ if( !testCaseStats.stdOut.empty() )
+ m_xml.scopedElement( "StdOut" ).writeText( trim( StringRef(testCaseStats.stdOut) ), XmlFormatting::Newline );
+ if( !testCaseStats.stdErr.empty() )
+ m_xml.scopedElement( "StdErr" ).writeText( trim( StringRef(testCaseStats.stdErr) ), XmlFormatting::Newline );
+
+ m_xml.endElement();
+ }
+
+ void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
+ StreamingReporterBase::testRunEnded( testRunStats );
+ m_xml.scopedElement( "OverallResults" )
+ .writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed )
+ .writeAttribute( "failures"_sr, testRunStats.totals.assertions.failed )
+ .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk )
+ .writeAttribute( "skips"_sr, testRunStats.totals.assertions.skipped );
+ m_xml.scopedElement( "OverallResultsCases")
+ .writeAttribute( "successes"_sr, testRunStats.totals.testCases.passed )
+ .writeAttribute( "failures"_sr, testRunStats.totals.testCases.failed )
+ .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk )
+ .writeAttribute( "skips"_sr, testRunStats.totals.testCases.skipped );
+ m_xml.endElement();
+ }
+
+ void XmlReporter::benchmarkPreparing( StringRef name ) {
+ m_xml.startElement("BenchmarkResults")
+ .writeAttribute("name"_sr, name);
+ }
+
+ void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
+ m_xml.writeAttribute("samples"_sr, info.samples)
+ .writeAttribute("resamples"_sr, info.resamples)
+ .writeAttribute("iterations"_sr, info.iterations)
+ .writeAttribute("clockResolution"_sr, info.clockResolution)
+ .writeAttribute("estimatedDuration"_sr, info.estimatedDuration)
+ .writeComment("All values in nano seconds"_sr);
+ }
+
+ void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+ m_xml.scopedElement("mean")
+ .writeAttribute("value"_sr, benchmarkStats.mean.point.count())
+ .writeAttribute("lowerBound"_sr, benchmarkStats.mean.lower_bound.count())
+ .writeAttribute("upperBound"_sr, benchmarkStats.mean.upper_bound.count())
+ .writeAttribute("ci"_sr, benchmarkStats.mean.confidence_interval);
+ m_xml.scopedElement("standardDeviation")
+ .writeAttribute("value"_sr, benchmarkStats.standardDeviation.point.count())
+ .writeAttribute("lowerBound"_sr, benchmarkStats.standardDeviation.lower_bound.count())
+ .writeAttribute("upperBound"_sr, benchmarkStats.standardDeviation.upper_bound.count())
+ .writeAttribute("ci"_sr, benchmarkStats.standardDeviation.confidence_interval);
+ m_xml.scopedElement("outliers")
+ .writeAttribute("variance"_sr, benchmarkStats.outlierVariance)
+ .writeAttribute("lowMild"_sr, benchmarkStats.outliers.low_mild)
+ .writeAttribute("lowSevere"_sr, benchmarkStats.outliers.low_severe)
+ .writeAttribute("highMild"_sr, benchmarkStats.outliers.high_mild)
+ .writeAttribute("highSevere"_sr, benchmarkStats.outliers.high_severe);
+ m_xml.endElement();
+ }
+
+ void XmlReporter::benchmarkFailed(StringRef error) {
+ m_xml.scopedElement("failed").
+ writeAttribute("message"_sr, error);
+ m_xml.endElement();
+ }
+
+ void XmlReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
+ auto outerTag = m_xml.scopedElement("AvailableReporters");
+ for (auto const& reporter : descriptions) {
+ auto inner = m_xml.scopedElement("Reporter");
+ m_xml.startElement("Name", XmlFormatting::Indent)
+ .writeText(reporter.name, XmlFormatting::None)
+ .endElement(XmlFormatting::Newline);
+ m_xml.startElement("Description", XmlFormatting::Indent)
+ .writeText(reporter.description, XmlFormatting::None)
+ .endElement(XmlFormatting::Newline);
+ }
+ }
+
+ void XmlReporter::listListeners(std::vector<ListenerDescription> const& descriptions) {
+ auto outerTag = m_xml.scopedElement( "RegisteredListeners" );
+ for ( auto const& listener : descriptions ) {
+ auto inner = m_xml.scopedElement( "Listener" );
+ m_xml.startElement( "Name", XmlFormatting::Indent )
+ .writeText( listener.name, XmlFormatting::None )
+ .endElement( XmlFormatting::Newline );
+ m_xml.startElement( "Description", XmlFormatting::Indent )
+ .writeText( listener.description, XmlFormatting::None )
+ .endElement( XmlFormatting::Newline );
+ }
+ }
+
+ void XmlReporter::listTests(std::vector<TestCaseHandle> const& tests) {
+ auto outerTag = m_xml.scopedElement("MatchingTests");
+ for (auto const& test : tests) {
+ auto innerTag = m_xml.scopedElement("TestCase");
+ auto const& testInfo = test.getTestCaseInfo();
+ m_xml.startElement("Name", XmlFormatting::Indent)
+ .writeText(testInfo.name, XmlFormatting::None)
+ .endElement(XmlFormatting::Newline);
+ m_xml.startElement("ClassName", XmlFormatting::Indent)
+ .writeText(testInfo.className, XmlFormatting::None)
+ .endElement(XmlFormatting::Newline);
+ m_xml.startElement("Tags", XmlFormatting::Indent)
+ .writeText(testInfo.tagsAsString(), XmlFormatting::None)
+ .endElement(XmlFormatting::Newline);
+
+ auto sourceTag = m_xml.scopedElement("SourceInfo");
+ m_xml.startElement("File", XmlFormatting::Indent)
+ .writeText(testInfo.lineInfo.file, XmlFormatting::None)
+ .endElement(XmlFormatting::Newline);
+ m_xml.startElement("Line", XmlFormatting::Indent)
+ .writeText(std::to_string(testInfo.lineInfo.line), XmlFormatting::None)
+ .endElement(XmlFormatting::Newline);
+ }
+ }
+
+ void XmlReporter::listTags(std::vector<TagInfo> const& tags) {
+ auto outerTag = m_xml.scopedElement("TagsFromMatchingTests");
+ for (auto const& tag : tags) {
+ auto innerTag = m_xml.scopedElement("Tag");
+ m_xml.startElement("Count", XmlFormatting::Indent)
+ .writeText(std::to_string(tag.count), XmlFormatting::None)
+ .endElement(XmlFormatting::Newline);
+ auto aliasTag = m_xml.scopedElement("Aliases");
+ for (auto const& alias : tag.spellings) {
+ m_xml.startElement("Alias", XmlFormatting::Indent)
+ .writeText(alias, XmlFormatting::None)
+ .endElement(XmlFormatting::Newline);
+ }
+ }
+ }
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include <functional>
+
+#include "catch.hpp"
+
+#ifdef __GNUC__
+// for CATCH's CHECK macro
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+using namespace sim::asio;
+using namespace sim::chrono;
+using sim::simulation;
+using sim::default_config;
+using namespace std::placeholders;
+
+namespace {
+
+int num_incoming = 0;
+int num_connected = 0;
+
+int counter = 0;
+
+void incoming_connection(boost::system::error_code const& ec
+ , ip::tcp::socket& sock, ip::tcp::acceptor& listener)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+ if (ec)
+ {
+ std::printf("[%4d] error while accepting connection: %s\n"
+ , millis, ec.message().c_str());
+ return;
+ }
+
+ ++num_incoming;
+
+ std::printf("[%4d] received incoming connection\n", millis);
+ sock.close();
+
+ listener.async_accept(sock, std::bind(&incoming_connection
+ , _1, std::ref(sock), std::ref(listener)));
+}
+
+void on_connected(boost::system::error_code const& ec
+ , ip::tcp::socket& sock)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+ if (ec)
+ {
+ std::printf("[%4d] error while connecting: %s\n", millis, ec.message().c_str());
+ return;
+ }
+
+ ++num_connected;
+
+ std::printf("[%4d] made outgoing connection\n", millis);
+ sock.close();
+
+ if (++counter > 5) return;
+
+ boost::system::error_code err;
+ sock.open(ip::tcp::v4(), err);
+ if (err) std::printf("[%4d] open failed: %s\n", millis, err.message().c_str());
+ sock.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
+ , 1337), std::bind(&on_connected, _1, std::ref(sock)));
+}
+
+}
+
+TEST_CASE("accept a connection multiple times on the same socket", "[accept]")
+{
+ default_config cfg;
+ simulation sim(cfg);
+ io_context incoming_ios(sim, ip::make_address_v4("40.30.20.10"));
+ io_context outgoing_ios(sim, ip::make_address_v4("10.20.30.40"));
+ ip::tcp::acceptor listener(incoming_ios);
+
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+
+ boost::system::error_code ec;
+ listener.open(ip::tcp::v4(), ec);
+ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
+ listener.bind(ip::tcp::endpoint(ip::address(), 1337), ec);
+ if (ec) std::printf("[%4d] bind failed: %s\n", millis, ec.message().c_str());
+ listener.listen(10, ec);
+ if (ec) std::printf("[%4d] listen failed: %s\n", millis, ec.message().c_str());
+
+ ip::tcp::socket incoming(incoming_ios);
+ listener.async_accept(incoming
+ , std::bind(&incoming_connection, _1, std::ref(incoming)
+ , std::ref(listener)));
+
+ std::printf("[%4d] connecting\n", millis);
+ ip::tcp::socket outgoing(outgoing_ios);
+ outgoing.open(ip::tcp::v4(), ec);
+ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
+ outgoing.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
+ , 1337), std::bind(&on_connected, _1, std::ref(outgoing)));
+
+ sim.run();
+
+ CHECK(num_incoming == 6);
+ CHECK(num_connected == 6);
+
+ millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include <functional>
+
+#include "catch.hpp"
+
+#ifdef __GNUC__
+// for CATCH's CHECK macro
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+using namespace sim;
+using namespace sim::asio::ip;
+using namespace sim::chrono;
+using sim::simulation;
+using sim::default_config;
+using namespace std::placeholders;
+
+namespace {
+
+char receive_buf[1000];
+char send_buf[1000];
+
+int num_ipv6 = 0;
+int num_ipv4 = 0;
+
+}
+
+void on_receive(boost::system::error_code const& ec, std::size_t /* bytes_transferred */
+ , udp::socket& s)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+
+ if (ec)
+ {
+ std::printf("[%4d] error while receiving: %s\n", millis, ec.message().c_str());
+ return;
+ }
+
+ std::printf("[%4d] received packet on %s\n", millis,
+ s.local_endpoint().address().to_string().c_str());
+
+ if (s.local_endpoint().address().is_v4())
+ {
+ ++num_ipv4;
+ }
+ else
+ {
+ ++num_ipv6;
+ }
+}
+
+TEST_CASE("one node can have multiple addresses (UDP)", "[multi-homed]")
+{
+ default_config cfg;
+ simulation sim(cfg);
+
+ // the machine receiving packets has two IP addresses
+ asio::io_context incoming_ios(sim, {
+ make_address_v4("40.30.20.10"),
+ make_address_v6("ff::dead:beef:1337")} );
+ asio::io_context outgoing_ios(sim, make_address_v4("10.20.30.40"));
+
+ // we create two sockets for it, one for each interface
+ udp::socket incoming_v4(incoming_ios);
+ udp::socket incoming_v6(incoming_ios);
+ udp::socket outgoing(outgoing_ios);
+
+ boost::system::error_code ec;
+ incoming_v4.open(udp::v4(), ec);
+ REQUIRE(!ec);
+ incoming_v4.bind(udp::endpoint(make_address_v4("40.30.20.10"), 1337), ec);
+ REQUIRE(!ec);
+ incoming_v4.async_receive(asio::buffer(receive_buf
+ , sizeof(receive_buf)), std::bind(&on_receive, _1, _2
+ , std::ref(incoming_v4)));
+
+ incoming_v6.open(udp::v6(), ec);
+ REQUIRE(!ec);
+ incoming_v6.bind(udp::endpoint(make_address_v6("ff::dead:beef:1337"), 1337), ec);
+ REQUIRE(!ec);
+ incoming_v6.async_receive(asio::buffer(receive_buf
+ , sizeof(receive_buf)), std::bind(&on_receive, _1, _2
+ , std::ref(incoming_v6)));
+
+ outgoing.open(udp::v4(), ec);
+ REQUIRE(!ec);
+
+ outgoing.non_blocking(true);
+ REQUIRE(!ec);
+
+ // send a packet to the IPv4 address
+ outgoing.send_to(asio::buffer(send_buf, sizeof(send_buf))
+ , udp::endpoint(make_address_v4("40.30.20.10"), 1337), 0, ec);
+ REQUIRE(!ec);
+
+ // and a packet to the IPv6 address
+ outgoing.send_to(asio::buffer(send_buf, sizeof(send_buf))
+ , udp::endpoint(make_address_v6("ff::dead:beef:1337"), 1337), 0, ec);
+ REQUIRE(!ec);
+
+ sim.run();
+
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+
+ CHECK(millis == 43);
+ CHECK(num_ipv4 == 1);
+ CHECK(num_ipv6 == 1);
+}
+
+TEST_CASE("one node can have multiple addresses (TCP)", "[multi-homed]")
+{
+ default_config cfg;
+ simulation sim(cfg);
+
+ const unsigned short listen_port = 4242;
+
+ // the machine receiving packets has two IP addresses
+ asio::io_context incoming_ios(sim, {
+ make_address_v4("40.30.20.10"),
+ make_address_v6("ff::dead:beef:1337")} );
+
+ // the machine sending packets has two IP addresses
+ asio::io_context outgoing_ios(sim, {
+ make_address_v4("10.20.30.40"),
+ make_address_v6("ff::abad:cafe:1337")
+ });
+
+ // we create two acceptors for it, one for each interface
+ asio::ip::tcp::acceptor incoming_v4(incoming_ios);
+ asio::ip::tcp::acceptor incoming_v6(incoming_ios);
+
+ tcp::socket outgoing_v4(outgoing_ios);
+ tcp::socket outgoing_v6(outgoing_ios);
+
+ boost::system::error_code ec;
+
+ incoming_v4.open(tcp::v4(), ec);
+ REQUIRE(!ec);
+ incoming_v4.bind(tcp::endpoint(address_v4::any(), listen_port));
+ REQUIRE(!ec);
+ incoming_v4.listen();
+
+ incoming_v6.open(tcp::v6(), ec);
+ REQUIRE(!ec);
+ incoming_v6.bind(tcp::endpoint(address_v6::any(), listen_port));
+ REQUIRE(!ec);
+ incoming_v6.listen();
+
+ int num_incoming_v4 = 0;
+ int num_incoming_v6 = 0;
+
+ tcp::socket incoming_socket(incoming_ios);
+ incoming_v4.async_accept(incoming_socket, [&] (boost::system::error_code ec) {
+ REQUIRE(!ec);
+ CHECK(incoming_socket.remote_endpoint().address() == make_address_v4("10.20.30.40"));
+ num_incoming_v4++;
+ incoming_socket.close();
+ });
+
+ incoming_v6.async_accept(incoming_socket, [&] (boost::system::error_code ec) {
+ REQUIRE(!ec);
+ CHECK(incoming_socket.remote_endpoint().address() == make_address_v6("ff::abad:cafe:1337"));
+ num_incoming_v6++;
+ incoming_socket.close();
+ });
+
+ // connect via ipv4
+ outgoing_v4.open(tcp::v4(), ec);
+ REQUIRE(!ec);
+ auto endpoint_v4 = asio::ip::tcp::endpoint(asio::ip::make_address("40.30.20.10"), listen_port);
+ outgoing_v4.async_connect(endpoint_v4, [] (boost::system::error_code ec) {
+ REQUIRE(!ec);
+ });
+ sim.run();
+
+ CHECK(num_incoming_v4 == 1);
+ CHECK(num_incoming_v6 == 0);
+
+ // connect via ipv6
+ outgoing_v6.open(tcp::v6(), ec);
+ REQUIRE(!ec);
+ auto endpoint_v6 = asio::ip::tcp::endpoint(asio::ip::make_address("ff::dead:beef:1337"), listen_port);
+ outgoing_v6.async_connect(endpoint_v6, [] (boost::system::error_code ec) {
+ REQUIRE(!ec);
+ });
+
+ sim.run();
+
+ CHECK(num_incoming_v4 == 1);
+ CHECK(num_incoming_v6 == 1);
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include <functional>
+#include "catch.hpp"
+
+#ifdef __GNUC__
+// for CATCH's CHECK macro
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+using namespace sim::asio;
+using namespace sim::chrono;
+using sim::simulation;
+using sim::default_config;
+using namespace std::placeholders;
+
+char send_buffer[10000];
+char recv_buffer[10000];
+int num_received = 0;
+int num_sent = 0;
+
+void on_sent(boost::system::error_code const& ec, std::size_t bytes_transferred
+ , ip::tcp::socket& sock)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+ if (ec)
+ {
+ std::printf("[%4d] send error %s\n", millis, ec.message().c_str());
+ return;
+ }
+
+ num_sent += int(bytes_transferred);
+ std::printf("[%4d] sent %d bytes (total: %d)\n"
+ , millis, int(bytes_transferred), num_sent);
+
+ if (num_sent < 1000000)
+ {
+ sock.async_write_some(sim::asio::buffer(send_buffer
+ , (std::min)(1000000 - num_sent, int(sizeof(send_buffer))))
+ , std::bind(&on_sent, _1, _2, std::ref(sock)));
+ return;
+ }
+ std::printf("closing\n");
+ sock.close();
+}
+
+void on_receive(boost::system::error_code const& ec, ip::tcp::socket& sock)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+ if (ec)
+ {
+ std::printf("[%4d] receive error %s\n", millis, ec.message().c_str());
+ return;
+ }
+
+ boost::system::error_code err;
+ std::size_t bytes_transferred = sock.read_some(sim::asio::buffer(
+ recv_buffer, sizeof(recv_buffer)), err);
+ if (err && err != boost::system::error_code(error::would_block))
+ {
+ std::printf("[%4d] receive error %s\n", millis, err.message().c_str());
+ return;
+ }
+
+ num_received += int(bytes_transferred);
+
+ std::printf("[%4d] received %d bytes (total: %d)\n"
+ , millis, int(bytes_transferred), num_received);
+
+ sock.async_wait(ip::tcp::socket::wait_read
+ , std::bind(&on_receive, _1, std::ref(sock)));
+}
+
+void incoming_connection(boost::system::error_code const& ec
+ , ip::tcp::socket& sock, ip::tcp::endpoint const& ep)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+ if (ec)
+ {
+ std::printf("[%4d] error while accepting connection: %s\n"
+ , millis, ec.message().c_str());
+ return;
+ }
+
+ boost::system::error_code err;
+ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
+ if (ec) std::printf("[%4d] local_endpoint failed: %s\n", millis, ec.message().c_str());
+ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
+ if (ec) std::printf("[%4d] remote_endpoint failed: %s\n", millis, ec.message().c_str());
+ std::printf("[%4d] received incoming connection from: %s:%d. local endpoint: %s:%d\n"
+ , millis, ep.address().to_string().c_str(), ep.port()
+ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
+ CHECK(local_endpoint.port() == 1337);
+ CHECK(local_endpoint.address().to_string() == "40.30.20.10");
+ CHECK(remote_endpoint.port() != 0);
+ CHECK(remote_endpoint.address().to_string() == "10.20.30.40");
+
+ sock.non_blocking(true);
+ if (err) std::printf("[%4d] ioctl failed: %s\n", millis, err.message().c_str());
+
+ sock.async_wait(ip::tcp::socket::wait_read
+ , std::bind(&on_receive, _1, std::ref(sock)));
+}
+
+void on_connected(boost::system::error_code const& ec
+ , ip::tcp::socket& sock)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+ if (ec)
+ {
+ std::printf("[%4d] error while connecting: %s\n", millis, ec.message().c_str());
+ return;
+ }
+
+ boost::system::error_code err;
+ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
+ if (ec) std::printf("[%4d] remote_endpoint failed: %s\n", millis, ec.message().c_str());
+ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
+ if (ec) std::printf("[%4d] local_endpoint failed: %s\n", millis, ec.message().c_str());
+ std::printf("[%4d] made outgoing connection to: %s:%d. local endpoint: %s:%d\n"
+ , millis
+ , remote_endpoint.address().to_string().c_str(), remote_endpoint.port()
+ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
+
+ CHECK(remote_endpoint.port() == 1337);
+ CHECK(remote_endpoint.address().to_string() == "40.30.20.10");
+ CHECK(local_endpoint.port() != 0);
+ CHECK(local_endpoint.address().to_string() == "10.20.30.40");
+
+ std::printf("sending %d bytes\n", int(sizeof(send_buffer)));
+ sock.async_write_some(sim::asio::buffer(send_buffer, sizeof(send_buffer))
+ , std::bind(&on_sent, _1, _2, std::ref(sock)));
+}
+
+TEST_CASE("receive null_buffers", "[null_buffers]")
+{
+ default_config cfg;
+ simulation sim(cfg);
+ io_context incoming_ios(sim, ip::make_address_v4("40.30.20.10"));
+ io_context outgoing_ios(sim, ip::make_address_v4("10.20.30.40"));
+ ip::tcp::acceptor listener(incoming_ios);
+
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+
+ boost::system::error_code ec;
+ listener.open(ip::tcp::v4(), ec);
+ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
+ listener.bind(ip::tcp::endpoint(ip::address(), 1337), ec);
+ if (ec) std::printf("[%4d] bind failed: %s\n", millis, ec.message().c_str());
+ listener.listen(10, ec);
+ if (ec) std::printf("[%4d] listen failed: %s\n", millis, ec.message().c_str());
+
+ dump_network_graph(sim, "null_buffers.dot");
+
+ ip::tcp::socket incoming(incoming_ios);
+ ip::tcp::endpoint remote_endpoint;
+ listener.async_accept(incoming, remote_endpoint
+ , std::bind(&incoming_connection, _1, std::ref(incoming)
+ , std::cref(remote_endpoint)));
+
+ std::printf("[%4d] connecting\n", millis);
+ ip::tcp::socket outgoing(outgoing_ios);
+ outgoing.open(ip::tcp::v4(), ec);
+ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
+ outgoing.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
+ , 1337), std::bind(&on_connected, _1, std::ref(outgoing)));
+
+ sim.run();
+
+ millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+ std::printf("num_sent: %d num_received: %d\n"
+ , num_sent, num_received);
+
+ CHECK(num_received == num_sent);
+ CHECK(num_received == 1000000);
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2017, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include <functional>
+
+#include "catch.hpp"
+#include "simulator/http_server.hpp" // for parse_request
+
+#ifdef __GNUC__
+// for CATCH's CHECK macro
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+TEST_CASE("parse GET request", "[parse_request]")
+{
+ auto str = "GET /foo/bar?x=4 HTTP/1.1\r\n\r\n";
+ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
+ CHECK(req.method == "GET");
+ CHECK(req.req == "/foo/bar?x=4");
+ CHECK(req.path == "/foo/bar");
+ CHECK(req.headers.empty());
+}
+
+TEST_CASE("request path is normalized (no leading slash)", "[parse_request]")
+{
+ auto str = "GET foo/bar HTTP/1.1\r\n\r\n";
+ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
+ CHECK(req.path == "/foo/bar");
+}
+
+TEST_CASE("request path is normalized (..)", "[parse_request]")
+{
+ auto str = "GET /foo/../foo/bar HTTP/1.1\r\n\r\n";
+ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
+ CHECK(req.path == "/foo/bar");
+}
+
+TEST_CASE("parse CONNECT request", "[parse_request]")
+{
+ auto str = "CONNECT 192.168.0.1:8888 HTTP/1.1\r\n\r\n";
+ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
+ CHECK(req.method == "CONNECT");
+ CHECK(req.req == "192.168.0.1:8888");
+ CHECK(req.path == "192.168.0.1:8888");
+ CHECK(req.headers.empty());
+}
+
+TEST_CASE("headers are parsed", "[parse_request]")
+{
+ auto str = "GET / HTTP/1.1\r\nX-Foo: Bar\r\n\r\n";
+ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
+ CHECK(!req.headers.empty());
+ CHECK(req.headers["x-foo"] == "Bar");
+}
+
+TEST_CASE("invalid formed request throws parse exception", "[parse_request]")
+{
+ auto str = "INVALID";
+ REQUIRE_THROWS_WITH(sim::parse_request(str, static_cast<int>(std::strlen(str))), Catch::Matchers::ContainsSubstring("parse failed"));
+}
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include <functional>
+
+#include "catch.hpp"
+
+#ifdef __GNUC__
+// for CATCH's CHECK macro
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+using namespace std::placeholders;
+using namespace sim;
+
+using asio::ip::make_address_v4;
+using asio::ip::address_v4;
+using duration = chrono::high_resolution_clock::duration;
+using chrono::duration_cast;
+using chrono::milliseconds;
+
+int num_lookups = 0;
+
+void on_name_lookup(boost::system::error_code const& /* ec */
+ , asio::ip::tcp::resolver::results_type ips)
+{
+ ++num_lookups;
+
+ std::vector<address_v4> expect = {
+ make_address_v4("1.2.3.4")
+ , make_address_v4("1.2.3.5")
+ , make_address_v4("1.2.3.6")
+ , make_address_v4("1.2.3.7") };
+
+ auto expect_it = expect.begin();
+
+ for (auto const& ip : ips)
+ {
+ assert(ip.endpoint().address() == *expect_it);
+ assert(ip.endpoint().port() == 8080);
+
+ ++expect_it;
+ }
+
+ assert(expect_it == expect.end());
+}
+
+void on_failed_name_lookup(boost::system::error_code const& ec
+ , asio::ip::tcp::resolver::results_type /* ips */)
+{
+ ++num_lookups;
+
+ assert(ec == boost::system::error_code(asio::error::host_not_found));
+}
+
+struct sim_config : sim::default_config
+{
+ duration hostname_lookup(
+ asio::ip::address const& requestor
+ , std::string hostname
+ , std::vector<asio::ip::address>& result
+ , boost::system::error_code& ec)
+ {
+ if (hostname == "test.com")
+ {
+ result = {
+ make_address_v4("1.2.3.4")
+ , make_address_v4("1.2.3.5")
+ , make_address_v4("1.2.3.6")
+ , make_address_v4("1.2.3.7")
+ };
+ return duration_cast<duration>(chrono::milliseconds(50));
+ }
+
+ return default_config::hostname_lookup(requestor, hostname, result, ec);
+ }
+};
+
+TEST_CASE("resolve multiple IPv4 addresses", "[resolver]") {
+ sim_config cfg;
+ simulation sim(cfg);
+
+ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
+ num_lookups = 0;
+
+ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
+
+ asio::ip::tcp::resolver resolver(ios);
+ resolver.async_resolve("test.com", "8080"
+ , std::bind(&on_name_lookup, _1, _2));
+
+ sim.run();
+
+ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
+
+ CHECK(millis == 50);
+ CHECK(num_lookups == 1);
+}
+
+TEST_CASE("resolve non-existent hostname", "[resolver]") {
+ sim_config cfg;
+ simulation sim(cfg);
+
+ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
+ num_lookups = 0;
+
+ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
+
+ asio::ip::tcp::resolver resolver(ios);
+ resolver.async_resolve("non-existent.com", "8080"
+ , std::bind(&on_failed_name_lookup, _1, _2));
+
+ sim.run();
+
+ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
+
+ CHECK(millis == 100);
+ CHECK(num_lookups == 1);
+}
+
+TEST_CASE("lookups resolve serially, compounding the latency", "[resolver]") {
+ sim_config cfg;
+ simulation sim(cfg);
+
+ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
+ num_lookups = 0;
+
+ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
+
+ asio::ip::tcp::resolver resolver(ios);
+ resolver.async_resolve("non-existent.com", "8080", std::bind(&on_failed_name_lookup, _1, _2));
+ resolver.async_resolve("non-existent.com", "8080", std::bind(&on_failed_name_lookup, _1, _2));
+
+ sim.run();
+
+ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
+
+ CHECK(millis == 200);
+ CHECK(num_lookups == 2);
+}
+
+TEST_CASE("resolve an IP address", "[resolver]") {
+ sim_config cfg;
+ simulation sim(cfg);
+
+ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
+ num_lookups = 0;
+
+ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
+
+ asio::ip::tcp::resolver resolver(ios);
+ resolver.async_resolve("10.10.10.10", "8080"
+ , [](boost::system::error_code const& /* ec */, asio::ip::tcp::resolver::results_type ips)
+ {
+ ++num_lookups;
+ std::vector<address_v4> expect = { make_address_v4("10.10.10.10") };
+
+ auto expect_it = expect.begin();
+ for (auto const& ip : ips)
+ {
+ assert(ip.endpoint().address() == *expect_it);
+ assert(ip.endpoint().port() == 8080);
+ ++expect_it;
+ }
+
+ assert(expect_it == expect.end());
+ });
+
+ sim.run();
+
+ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
+
+ CHECK(millis == 0);
+ CHECK(num_lookups == 1);
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include <functional>
+
+#include "catch.hpp"
+
+#ifdef __GNUC__
+// for CATCH's CHECK macro
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+using namespace sim::chrono;
+using namespace sim::asio;
+using sim::simulation;
+using sim::default_config;
+using namespace std::placeholders;
+
+namespace {
+
+ int counter = 0;
+ const int expected_timestamps[] = {1000, 2000, 4000, 7000, 11000 };
+
+ high_resolution_clock::time_point start;
+}
+
+void print_time(high_resolution_timer& timer
+ , boost::system::error_code const& ec)
+{
+ using namespace sim::chrono;
+
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now() - start).count());
+
+ std::printf("[%d] timer fired at: %d milliseconds. error: %s\n"
+ , counter
+ , millis
+ , ec.message().c_str());
+
+ if (ec)
+ {
+ CHECK(millis == 0);
+ return;
+ }
+
+ CHECK(millis == expected_timestamps[counter]);
+
+ ++counter;
+ if (counter < 5)
+ {
+ timer.expires_after(seconds(counter));
+ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
+ }
+}
+
+TEST_CASE("wait for timers", "[timer]")
+{
+ default_config cfg;
+ simulation sim(cfg);
+ io_context ios(sim, ip::make_address_v4("1.2.3.4"));
+ high_resolution_timer timer(ios);
+
+ start = high_resolution_clock::now();
+
+ timer.expires_after(seconds(10));
+ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
+
+ timer.cancel();
+ timer.expires_after(seconds(1));
+ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
+
+ sim.run();
+
+ CHECK(counter == 5);
+}
+
--- /dev/null
+/*
+
+Copyright (c) 2015, Arvid Norberg
+All rights reserved.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "simulator/simulator.hpp"
+#include <functional>
+#include <cstdio> // for printf
+#include "catch.hpp"
+
+#ifdef __GNUC__
+// for CATCH's CHECK macro
+#pragma GCC diagnostic ignored "-Wparentheses"
+#endif
+
+using namespace sim;
+using namespace sim::asio::ip;
+using namespace sim::chrono;
+using sim::simulation;
+using sim::default_config;
+using namespace std::placeholders;
+
+namespace {
+
+char receive_buf[1000];
+char send_buf[1000];
+
+int num_sent = 0;
+int num_received = 0;
+
+void on_receive(boost::system::error_code const& ec, std::size_t bytes_transferred
+ , udp::socket& s, udp::endpoint& ep)
+{
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+
+ if (ec)
+ {
+ std::printf("[%4d] error while receiving: %s\n", millis, ec.message().c_str());
+ return;
+ }
+
+ num_received += int(bytes_transferred);
+
+ std::printf("[%4d] received %d bytes from %s\n", millis
+ , int(bytes_transferred)
+ , ep.address().to_string().c_str());
+
+ if (bytes_transferred == 100 * 10) return;
+
+ s.async_receive_from(asio::buffer(receive_buf
+ , sizeof(receive_buf)), ep, std::bind(&on_receive, _1, _2
+ , std::ref(s), std::ref(ep)));
+}
+
+}
+
+TEST_CASE("send packet to udp socket", "[udp_socket]")
+{
+ default_config cfg;
+ simulation sim(cfg);
+ asio::io_context incoming_ios(sim, make_address_v4("40.30.20.10"));
+ asio::io_context outgoing_ios(sim, make_address_v4("10.20.30.40"));
+
+ udp::socket incoming(incoming_ios);
+ udp::socket outgoing(outgoing_ios);
+
+ boost::system::error_code ec;
+ incoming.open(udp::v4(), ec);
+ REQUIRE(!ec);
+ incoming.bind(udp::endpoint(address(), 1337), ec);
+ REQUIRE(!ec);
+
+ outgoing.open(udp::v4(), ec);
+ REQUIRE(!ec);
+
+ udp::endpoint remote_endpoint;
+ incoming.async_receive_from(asio::buffer(receive_buf,
+ sizeof(receive_buf)), remote_endpoint, std::bind(&on_receive, _1, _2
+ , std::ref(incoming), std::ref(remote_endpoint)));
+
+ outgoing.non_blocking(true);
+ REQUIRE(!ec);
+
+ for (int i = 1; i < 10; ++i)
+ {
+ num_sent += int(outgoing.send_to(asio::buffer(send_buf, 100 * i)
+ , udp::endpoint(make_address_v4("40.30.20.10"), 1337), 0, ec));
+ REQUIRE(!ec);
+ }
+
+ sim.run();
+
+ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+ .time_since_epoch()).count());
+
+ CHECK(millis == 56);
+ CHECK(num_sent == num_received);
+ CHECK(num_sent == 100 * 45);
+}
+
--- /dev/null
+using msvc : 14.1 ;
+using gcc ;
+
projects / libtorrent-rasterbar.git / commitdiff